so I have something of the form

(let [ans (om/transact! ...)]
  (if (:om.next/error ans)
    (throw (:om.next/error ans)))
  (. js/console log "ans: " ans))

got it all working!

@anmonteiro : actually, I think https://github.com/omcljs/om/blob/f444a118da4ec263795ade49bfd7c4e1c3478b71/src/main/om/next/impl/parser.cljc#L281 is the line where the exception is being thrown / caught

you’re correct

but the error will be in the return of transact!

because transact! calls the parser

@anmonteiro : I just realized, you're one of the git contributors to that file so I am rethrowing with

(let [ans (om/transact! ...)]
  (when-let [err (get-in ans ['window/new :om.next/error])]
    (throw err)))

the errors are caught in the parser so that every transaction can run to the end

I can see how that is the right thing to do during production. During dev time, I want the transaction to die there, so I can debug it, save files, and have it reload. Is there some way, where instead of throwing an exception, I make a call to the browser (direclty from cljs land) so it triggers the debugger [ which won't be caught ] instead of throwing an exception [ which would be caught ]

@qqq so you can probably throw in the parser by throwing an exception-info with {:type :om.next/abort}

follow this code path: https://github.com/omcljs/om/blob/master/src/main/om/next/impl/parser.cljc#L237

@anmonteiro : I'm not sure why this works, but it appears changing my

(assert (...)) ;; which the parser catches

========== If I have access to the reconciler, is there a way to directly call a mutate? Even if I'm outside of a OM UI Element? I feel like this should be doable but I can't figure out how to do it.

@qqq you can call transact! on the reconciler

@anmonteiro I tried replacing:

(om/transact! this '[(foo/new)]

(om/transact! reconciler '[(foo/new)])

oh, it works now

my typo was from elsewhere; thanks !

qqq: FWIW, in chrome dev tools you can specify opening the debugger even for “caught” exceptions

yeah, but quite a few libraries use "caught" exceptions as control flow

which unforunately negates the debug technique @matthavener

yeah, there are two in the closure library startup

but (js-debugger) is nice -- can't be caught, and pops me directly into debugger

yeah that sounds really nice. I’ll have to try that sometime. reminds me of asserting or int *p = 0; *p = 1; in C++

oh, for C++, 99% of my errors were reading uninitialized, writing out of bounds, so valgrind was life saver

I'm looking at https://anmonteiro.com/2016/01/om-next-query-syntax/, which is > 1 year old now; it says that the read param syntax is

[({:some/key [:subkey/one :subkey/two]} {:some/param 42})]

[{(:some/key {:some/param 42}) [:subkey/one :subkey/two]}]

if I'm using datascript as my db, and I'm not doing remotes; does om offer anything over reframe ?

@peeja both valid

oh wait

let me re-read the post

@peeja hrm OK so the first one is correct

it’s also what David showcased in one of the earliest Om Next talks https://pbs.twimg.com/media/CQzq8FrW8AAG_lP.png:large

the second one could work 🙂

but I don’t know if it will

basically the difference is in 1) you’re parameterizing the join, in 2) you’re parameterizing the join key

Oh, I guess that makes sense…

The first one seems more readable to me, with the assumption that subqueries grow larger than param maps

agreed

@peeja is the big Om Next migration still underway? 🙂

I’m interested to know how it’s going

Yeah, I'm trying to work out the best way to query for deeply nested stuff ATM

@anmonteiro Speaking of which: if you were going to ask the server for data (`[:...]`) about a particular build (`/gh/some-org/some-project/30`), would you construct the query as:

[{[:build/by-a-whole-lotta-stuff {:organization/vcs-type :vcs-type/github
                                  :organization/name "some-org"
                                  :project/name "some-project"
                                  :build/number 30}]
  [:...]}]

[{[:organization/by-vcs-type-and-name {:organization/vcs-type :vcs-type/github
                                       :organization/name "some-org"}]
  [({:organization/projects
     [({:project/builds
        [:...]}
       {:where {:run/number 30}})]}
    {:where {:project/name "some-project"}})]}]

I feel like Om queries don't quite solve this problem well, but I may just not have my head in the right place yet.

2 feels weird

why not just:

[({[:build/by-whatever-it-needs-to-be x] [:.....]} {:params here})]

I've run in to problems using [{(:key {:params here}) [:foo]}] in earlier versions of om.next. Since then I've stuck to [({:key [:foo]} {:params here})] and had no problems