joist-core 2.4.0-next.37 → 2.4.0-next.39

package/build/defaults.js.map

@@ -1 +1 @@
-{"version":3,"file":"defaults.js","names":["#loadHint","#deps","#deferreds"],"sources":["../src/defaults.ts"],"sourcesContent":["import { Deferred } from \"joist-utils\";\nimport { getInstanceData } from \"src/BaseEntity.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport {\n  type EntityMetadata,\n  type EnumField,\n  type Field,\n  type PrimitiveField,\n  getBaseAndSelfMetas,\n  getMetadata,\n} from \"src/EntityMetadata.ts\";\nimport { setField } from \"src/fields.ts\";\nimport { normalizeHint } from \"src/normalizeHints.ts\";\nimport { type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { isLoadedReference } from \"src/relations/index.ts\";\nimport { runInTrustedContext } from \"src/trusted.ts\";\nimport { fail, failIfAnyRejected } from \"src/utils.ts\";\n\nexport function hasDefaultValue(meta: EntityMetadata, fieldName: string): boolean {\n  return getBaseAndSelfMetas(meta).some(\n    (m) => fieldName in m.config.__data.syncDefaults || fieldName in m.config.__data.asyncDefaults,\n  );\n}\n\n/** Run the sync defaults for `entity`. */\nexport function setSyncDefaults(entity: Entity): void {\n  return runInTrustedContext(() => {\n    const meta = getMetadata(entity);\n    // Allow subtypes to override base setDefaults\n    const syncDefaults: Record<string, any> = getBaseAndSelfMetas(meta).reduce(\n      (acc, m) => ({ ...acc, ...m.config.__data.syncDefaults }),\n      {},\n    );\n    for (const [fieldName, maybeFn] of Object.entries(syncDefaults)) {\n      const field = meta.allFields[fieldName];\n      // Use allFields in case a subtype sets a default for one of its base fields\n      if (\n        (field.kind === \"primitive\" || field.kind === \"enum\") &&\n        (field as PrimitiveField | EnumField).derived === \"async\"\n      ) {\n        // If this is an AsyncReactiveField, we want to push in a default, but setOpts is called\n        // from the codegen constructor, so the user-defined `hasAsyncReactiveField` fields will\n        // not have been initialized yet (i.e. `entity[field]` will be undefined and not yet an\n        // `instanceof AsyncReactiveField`). Thankfully we can just use setField.\n        const value = maybeFn instanceof Function ? maybeFn(entity) : maybeFn;\n        setField(entity, fieldName, value);\n      } else if (!isRelation(field)) {\n        const hasBeenSet = fieldName in getInstanceData(entity).data;\n        if (!hasBeenSet) {\n          const value = maybeFn instanceof Function ? maybeFn(entity) : maybeFn;\n          // If the value is undefined, leave it unset, so that a default invoked during\n          // the constructor being called (before any other opts are set) can be called\n          // again during `em.flush` and get an opportunity to observe other fields.\n          if (value !== undefined) {\n            (entity as any)[fieldName] = value;\n          }\n        }\n      } else {\n        const value = (entity as any)[fieldName];\n        if (isLoadedReference(value) && !value.isSet && !value.hasBeenSet) {\n          // A sync default usually would never be for a reference, because reference defaults usually\n          // require a field hint (so would be async) to get \"the other entity\". However, something like:\n          // `config.setDefault(\"original\", (self) => self);` is technically valid.\n          value.set(maybeFn instanceof Function ? maybeFn(entity) : maybeFn);\n        }\n      }\n    }\n  });\n}\n\n/** Runs the async defaults for all inserted entities in `todos`. */\nexport async function setAsyncDefaults(\n  suppressedTypeErrors: Error[],\n  ctx: unknown,\n  // We want this to be per-subtype, so that a subtype can have its own default, and we still invoke\n  // the subtype `setOnEntities(...all subtype entities...)` and `setOnEntities(...any base types...)`\n  // as bulk calls.\n  insertsBySubType: Map<EntityMetadata, Entity[]>,\n): Promise<void> {\n  return runInTrustedContext(async () => {\n    const dt = new DependencyTracker(insertsBySubType);\n    const results = await Promise.allSettled(\n      [...insertsBySubType.entries()].flatMap(([meta, inserts]) => {\n        // configure will have copy/pasted base defaults into our config, so we can loop over it directly\n        return Object.values(meta.config.__data.asyncDefaults).map((df) =>\n          df.setOnEntities(ctx, dt, suppressedTypeErrors, meta, inserts),\n        );\n      }),\n    );\n    failIfAnyRejected(results);\n  });\n}\n\n/** Sets async defaults *synchronously*, only safe for factories with `DeepNew` entities. */\nexport function setAsyncDefaultsSynchronously(ctx: unknown, entity: Entity): void {\n  return runInTrustedContext(() => {\n    // configure will have copy/pasted base defaults into our config, so we can loop over it directly\n    for (const df of Object.values(getMetadata(entity).config.__data.asyncDefaults)) {\n      df.setOnFactoryEntity(ctx, entity);\n    }\n  });\n}\n\n/** Wraps the hint + lambda of an async `setDefault`. */\nexport class AsyncDefault<T extends Entity> {\n  readonly fieldName: string;\n  readonly fieldHint: ReactiveHint<T>;\n  readonly fn: (entity: any, ctx: any) => any;\n  #loadHint: any;\n  // We can't calc this until post-boot because it requires following metadata\n  #deps: DefaultDependency[] | undefined;\n\n  constructor(fieldName: string, fieldHint: ReactiveHint<T>, fn: (entity: T, ctx: any) => any) {\n    this.fieldName = fieldName;\n    this.fieldHint = fieldHint;\n    this.fn = fn;\n  }\n\n  /** Given a list of inserts of the same type/subtype, set ourselves on each of them. */\n  async setOnEntities(\n    ctx: any,\n    dt: DependencyTracker,\n    suppressedTypeErrors: Error[],\n    baseMetadata: EntityMetadata,\n    inserts: T[],\n  ): Promise<any> {\n    try {\n      // Ensure our dependencies have been set\n      // (...and only wait on dependencies that are actively being calculated)\n      const deps = this.deps(baseMetadata).filter((dep) => dt.hasMaybePending(dep.meta));\n      if (deps.length > 0) {\n        // console.log(\n        //   \"WAITING ON\",\n        //   deps.map((dep) => `${dep.meta.type}.${dep.fieldName}`),\n        //   `FOR ${baseMetadata.type}.${this.fieldName}`,\n        // );\n        // deps promises shouldn't reject, so we should be fine w/o allSettled here\n        await Promise.all(deps.map((dep) => dt.getDeferred(dep.meta, dep.fieldName).promise));\n      }\n\n      // Run our default for all entities, use allSettled to avoid leaving lambdas running if one fails\n      const results = await Promise.allSettled(\n        inserts\n          .map(async (entity) => {\n            if (!isRelation(baseMetadata.allFields[this.fieldName])) {\n              const hasBeenSet = this.fieldName in getInstanceData(entity).data;\n              if (!hasBeenSet) {\n                const value = await this.getValue(entity, ctx);\n                if (value !== undefined) {\n                  (entity as any)[this.fieldName] = value;\n                }\n              }\n            } else {\n              const value = (entity as any)[this.fieldName];\n              if (isLoadedReference(value) && !value.isSet && !value.hasBeenSet) {\n                const val = await this.getValue(entity, ctx);\n                if (val !== undefined) {\n                  value.set(val);\n                }\n              }\n            }\n          })\n          .map((promise) =>\n            promise.catch((reason) => {\n              // If we NPE-d because a required field wasn't set, hold on to this and\n              // let the validation failures reject the `em.flush` instead of us\n              if (reason instanceof TypeError) {\n                suppressedTypeErrors.push(reason);\n              } else {\n                throw reason;\n              }\n            }),\n          ),\n      );\n      failIfAnyRejected(results);\n    } finally {\n      // Mark ourselves as complete (from a `finally` just in case our `setDefault`\n      // blows up, we don't forever block the other defaults waiting on us).\n      // console.log(`FINISHED ${baseMetadata.type}.${this.fieldName}`);\n      dt.getDeferred(baseMetadata, this.fieldName).resolve();\n    }\n  }\n\n  setOnFactoryEntity(ctx: unknown, entity: T): void {\n    // If the lambda uses the `async` keyword, it definitely makes a promise, so don't invoke it\n    // from a synchronous factory call.\n    if (this.fn.constructor.name === \"AsyncFunction\") return;\n    const value = (entity as any)[this.fieldName];\n    try {\n      if (value === undefined || (isLoadedReference(value) && !value.isSet)) {\n        const val = this.fn(entity, ctx);\n        // Even though we checked `async () => ...` above, a lambda could still return a Promise\n        if (val instanceof Promise) {\n          throw new Error(\n            `Use the \\`async\\` keyword for the setDefault \"${this.fieldName}\" function that returns a Promise`,\n          );\n        } else if (val === undefined) {\n          // If val is undefined, let the setDefault get invoked again later\n        } else {\n          if (isLoadedReference(value)) {\n            value.set(val);\n          } else {\n            (entity as any)[this.fieldName] = val;\n          }\n        }\n      }\n    } catch (e) {\n      // It's likely common to get NPEs/TypeErrors from speculatively executing defaults\n      // pre-em.flush, i.e. we don't have the DependencyTracker/etc infra here, the lambdas\n      // could do a `book.author.get.name` and NPE on the `author.get.name`. So instead just\n      // suppress errors and assume `em.flush` will try again.\n      // ...we need to add a NotLoadedError\n      // if (!(e instanceof TypeError || e instanceof NotL)) {\n      //   throw e;\n      // }\n    }\n  }\n\n  /** For the given `entity`, returns what the default value should be. */\n  private getValue(entity: T, ctx: any): Promise<any> {\n    // We can't convert this until now, since it requires the `metadata`\n    this.#loadHint ??= convertToLoadHint(getMetadata(entity), this.fieldHint);\n    return entity.em.populate(entity, this.#loadHint).then((loaded) => this.fn(loaded, ctx));\n  }\n\n  // Calc once and cache\n  private deps(meta: EntityMetadata): DefaultDependency[] {\n    return (this.#deps ??= getDefaultDependencies(meta, this.fieldName, this.fieldHint));\n  }\n}\n\ntype DefaultDependency = {\n  meta: EntityMetadata;\n  fieldName: string;\n};\n\n/**\n * Given a `meta` and a nested field hint, return the meta+field tuples included within the hint.\n *\n * I.e. passing `{ author: { firstName: {}, publisher: \"name\" } }` would return `[[Author, \"firstName\"],\n * [Publisher, \"name\"]]`.\n */\nexport function getDefaultDependencies<T extends Entity>(\n  baseMeta: EntityMetadata<T>,\n  baseFieldName: string,\n  baseHint: ReactiveHint<T>,\n): DefaultDependency[] {\n  // Ensure the hint is an `{ ... }`\n  const deps: DefaultDependency[] = [];\n  const todo: [meta: EntityMetadata, hint: ReactiveHint<any>][] = [[baseMeta, normalizeHint(baseHint)]];\n  while (todo.length !== 0) {\n    const [meta, hint] = todo.pop()!;\n    for (const [fieldName, nestedHint] of Object.entries(hint)) {\n      const field = meta.allFields[fieldName];\n      // Super naive circular dependency detection\n      const isSameField = meta === baseMeta && fieldName === baseFieldName;\n      if (isSameField) continue;\n      // If this is an invalid hint, just ignore it, and assume someone else will fail on it\n      if (!field) continue;\n      switch (field.kind) {\n        case \"enum\":\n        case \"primitive\":\n          if (field.default === \"config\" && fieldName in meta.config.__data.asyncDefaults) {\n            deps.push({ meta, fieldName });\n          }\n          break;\n        case \"m2o\":\n          if (field.default === \"config\" && fieldName in meta.config.__data.asyncDefaults) {\n            deps.push({ meta, fieldName });\n          }\n          if (nestedHint) {\n            todo.push([field.otherMetadata(), normalizeHint(nestedHint)]);\n          }\n          break;\n        case \"o2o\":\n        case \"o2m\":\n        case \"m2m\":\n          if (nestedHint) {\n            todo.push([field.otherMetadata(), normalizeHint(nestedHint)]);\n          }\n          break;\n      }\n    }\n  }\n  return deps;\n}\n\n/**\n * This tracks cross-default dependencies that are active within a single `em.flush` loop.\n *\n * I.e. this is not a static \"the Author.firstName in general depends on Publisher.whatever\",\n * it tracks that we're actively inserting 10 new `Author` instances, and their `firstName`\n * default needs to wait until the `Publisher.whatever` fields have their async default\n * calculated.\n *\n * Really this is just a smaller wrapper around a map of `Deferred`s.\n */\nclass DependencyTracker {\n  // Create a map \"entityType -> fieldName -> deferred\"\n  #deferreds = new Map<string, Map<string, Deferred<void>>>();\n\n  constructor(insertsBySubType: Map<EntityMetadata, Entity[]>) {\n    // Seed it with any entities that we're actively inserting (as any dependencies to\n    // entities that aren't even having `setDefault` called can be skipped)\n    for (const meta of [...insertsBySubType.keys()]) {\n      this.#deferreds.set(meta.type, new Map());\n    }\n  }\n\n  hasMaybePending(meta: EntityMetadata): boolean {\n    return this.#deferreds.has(meta.type) ?? false;\n  }\n\n  getDeferred(meta: EntityMetadata, fieldName: string): Deferred<void> {\n    const map = this.#deferreds.get(meta.type) ?? fail(`No deferred check necessary for ${meta.type}.${fieldName}`);\n    let deferred = map.get(fieldName);\n    if (!deferred) {\n      deferred = new Deferred();\n      map.set(fieldName, deferred);\n    }\n    return deferred;\n  }\n}\n\nfunction isRelation(field: Field): boolean {\n  return field.kind !== \"primitive\" && field.kind !== \"enum\";\n}\n"],"mappings":"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"}
+{"version":3,"file":"defaults.js","names":[],"sources":["../src/defaults.ts"],"sourcesContent":["import { Deferred } from \"joist-utils\";\nimport { getInstanceData } from \"src/BaseEntity.ts\";\nimport { type Entity } from \"src/Entity.ts\";\nimport {\n  type EntityMetadata,\n  type EnumField,\n  type Field,\n  type PrimitiveField,\n  getBaseAndSelfMetas,\n  getMetadata,\n} from \"src/EntityMetadata.ts\";\nimport { setField } from \"src/fields.ts\";\nimport { normalizeHint } from \"src/normalizeHints.ts\";\nimport { type ReactiveHint, convertToLoadHint } from \"src/reactivity/reactiveHints.ts\";\nimport { isLoadedReference } from \"src/relations/index.ts\";\nimport { runInTrustedContext } from \"src/trusted.ts\";\nimport { fail, failIfAnyRejected } from \"src/utils.ts\";\n\nexport function hasDefaultValue(meta: EntityMetadata, fieldName: string): boolean {\n  return getBaseAndSelfMetas(meta).some(\n    (m) => fieldName in m.config.__data.syncDefaults || fieldName in m.config.__data.asyncDefaults,\n  );\n}\n\n/** Run the sync defaults for `entity`. */\nexport function setSyncDefaults(entity: Entity): void {\n  return runInTrustedContext(() => {\n    const meta = getMetadata(entity);\n    // Allow subtypes to override base setDefaults\n    const syncDefaults: Record<string, any> = getBaseAndSelfMetas(meta).reduce(\n      (acc, m) => ({ ...acc, ...m.config.__data.syncDefaults }),\n      {},\n    );\n    for (const [fieldName, maybeFn] of Object.entries(syncDefaults)) {\n      const field = meta.allFields[fieldName];\n      // Use allFields in case a subtype sets a default for one of its base fields\n      if (\n        (field.kind === \"primitive\" || field.kind === \"enum\") &&\n        (field as PrimitiveField | EnumField).derived === \"async\"\n      ) {\n        // If this is an AsyncReactiveField, we want to push in a default, but setOpts is called\n        // from the codegen constructor, so the user-defined `hasAsyncReactiveField` fields will\n        // not have been initialized yet (i.e. `entity[field]` will be undefined and not yet an\n        // `instanceof AsyncReactiveField`). Thankfully we can just use setField.\n        const value = maybeFn instanceof Function ? maybeFn(entity) : maybeFn;\n        setField(entity, fieldName, value);\n      } else if (!isRelation(field)) {\n        const hasBeenSet = fieldName in getInstanceData(entity).data;\n        if (!hasBeenSet) {\n          const value = maybeFn instanceof Function ? maybeFn(entity) : maybeFn;\n          // If the value is undefined, leave it unset, so that a default invoked during\n          // the constructor being called (before any other opts are set) can be called\n          // again during `em.flush` and get an opportunity to observe other fields.\n          if (value !== undefined) {\n            (entity as any)[fieldName] = value;\n          }\n        }\n      } else {\n        const value = (entity as any)[fieldName];\n        if (isLoadedReference(value) && !value.isSet && !value.hasBeenSet) {\n          // A sync default usually would never be for a reference, because reference defaults usually\n          // require a field hint (so would be async) to get \"the other entity\". However, something like:\n          // `config.setDefault(\"original\", (self) => self);` is technically valid.\n          value.set(maybeFn instanceof Function ? maybeFn(entity) : maybeFn);\n        }\n      }\n    }\n  });\n}\n\n/** Runs the async defaults for all inserted entities in `todos`. */\nexport async function setAsyncDefaults(\n  suppressedTypeErrors: Error[],\n  ctx: unknown,\n  // We want this to be per-subtype, so that a subtype can have its own default, and we still invoke\n  // the subtype `setOnEntities(...all subtype entities...)` and `setOnEntities(...any base types...)`\n  // as bulk calls.\n  insertsBySubType: Map<EntityMetadata, Entity[]>,\n): Promise<void> {\n  return runInTrustedContext(async () => {\n    const dt = new DependencyTracker(insertsBySubType);\n    const results = await Promise.allSettled(\n      [...insertsBySubType.entries()].flatMap(([meta, inserts]) => {\n        // configure will have copy/pasted base defaults into our config, so we can loop over it directly\n        return Object.values(meta.config.__data.asyncDefaults).map((df) =>\n          df.setOnEntities(ctx, dt, suppressedTypeErrors, meta, inserts),\n        );\n      }),\n    );\n    failIfAnyRejected(results);\n  });\n}\n\n/** Sets async defaults *synchronously*, only safe for factories with `DeepNew` entities. */\nexport function setAsyncDefaultsSynchronously(ctx: unknown, entity: Entity): void {\n  return runInTrustedContext(() => {\n    // configure will have copy/pasted base defaults into our config, so we can loop over it directly\n    for (const df of Object.values(getMetadata(entity).config.__data.asyncDefaults)) {\n      df.setOnFactoryEntity(ctx, entity);\n    }\n  });\n}\n\n/** Wraps the hint + lambda of an async `setDefault`. */\nexport class AsyncDefault<T extends Entity> {\n  readonly fieldName: string;\n  readonly fieldHint: ReactiveHint<T>;\n  readonly fn: (entity: any, ctx: any) => any;\n  #loadHint: any;\n  // We can't calc this until post-boot because it requires following metadata\n  #deps: DefaultDependency[] | undefined;\n\n  constructor(fieldName: string, fieldHint: ReactiveHint<T>, fn: (entity: T, ctx: any) => any) {\n    this.fieldName = fieldName;\n    this.fieldHint = fieldHint;\n    this.fn = fn;\n  }\n\n  /** Given a list of inserts of the same type/subtype, set ourselves on each of them. */\n  async setOnEntities(\n    ctx: any,\n    dt: DependencyTracker,\n    suppressedTypeErrors: Error[],\n    baseMetadata: EntityMetadata,\n    inserts: T[],\n  ): Promise<any> {\n    try {\n      // Ensure our dependencies have been set\n      // (...and only wait on dependencies that are actively being calculated)\n      const deps = this.deps(baseMetadata).filter((dep) => dt.hasMaybePending(dep.meta));\n      if (deps.length > 0) {\n        // console.log(\n        //   \"WAITING ON\",\n        //   deps.map((dep) => `${dep.meta.type}.${dep.fieldName}`),\n        //   `FOR ${baseMetadata.type}.${this.fieldName}`,\n        // );\n        // deps promises shouldn't reject, so we should be fine w/o allSettled here\n        await Promise.all(deps.map((dep) => dt.getDeferred(dep.meta, dep.fieldName).promise));\n      }\n\n      // Run our default for all entities, use allSettled to avoid leaving lambdas running if one fails\n      const results = await Promise.allSettled(\n        inserts\n          .map(async (entity) => {\n            if (!isRelation(baseMetadata.allFields[this.fieldName])) {\n              const hasBeenSet = this.fieldName in getInstanceData(entity).data;\n              if (!hasBeenSet) {\n                const value = await this.getValue(entity, ctx);\n                if (value !== undefined) {\n                  (entity as any)[this.fieldName] = value;\n                }\n              }\n            } else {\n              const value = (entity as any)[this.fieldName];\n              if (isLoadedReference(value) && !value.isSet && !value.hasBeenSet) {\n                const val = await this.getValue(entity, ctx);\n                if (val !== undefined) {\n                  value.set(val);\n                }\n              }\n            }\n          })\n          .map((promise) =>\n            promise.catch((reason) => {\n              // If we NPE-d because a required field wasn't set, hold on to this and\n              // let the validation failures reject the `em.flush` instead of us\n              if (reason instanceof TypeError) {\n                suppressedTypeErrors.push(reason);\n              } else {\n                throw reason;\n              }\n            }),\n          ),\n      );\n      failIfAnyRejected(results);\n    } finally {\n      // Mark ourselves as complete (from a `finally` just in case our `setDefault`\n      // blows up, we don't forever block the other defaults waiting on us).\n      // console.log(`FINISHED ${baseMetadata.type}.${this.fieldName}`);\n      dt.getDeferred(baseMetadata, this.fieldName).resolve();\n    }\n  }\n\n  setOnFactoryEntity(ctx: unknown, entity: T): void {\n    // If the lambda uses the `async` keyword, it definitely makes a promise, so don't invoke it\n    // from a synchronous factory call.\n    if (this.fn.constructor.name === \"AsyncFunction\") return;\n    const value = (entity as any)[this.fieldName];\n    try {\n      if (value === undefined || (isLoadedReference(value) && !value.isSet)) {\n        const val = this.fn(entity, ctx);\n        // Even though we checked `async () => ...` above, a lambda could still return a Promise\n        if (val instanceof Promise) {\n          throw new Error(\n            `Use the \\`async\\` keyword for the setDefault \"${this.fieldName}\" function that returns a Promise`,\n          );\n        } else if (val === undefined) {\n          // If val is undefined, let the setDefault get invoked again later\n        } else {\n          if (isLoadedReference(value)) {\n            value.set(val);\n          } else {\n            (entity as any)[this.fieldName] = val;\n          }\n        }\n      }\n    } catch (e) {\n      // It's likely common to get NPEs/TypeErrors from speculatively executing defaults\n      // pre-em.flush, i.e. we don't have the DependencyTracker/etc infra here, the lambdas\n      // could do a `book.author.get.name` and NPE on the `author.get.name`. So instead just\n      // suppress errors and assume `em.flush` will try again.\n      // ...we need to add a NotLoadedError\n      // if (!(e instanceof TypeError || e instanceof NotL)) {\n      //   throw e;\n      // }\n    }\n  }\n\n  /** For the given `entity`, returns what the default value should be. */\n  private getValue(entity: T, ctx: any): Promise<any> {\n    // We can't convert this until now, since it requires the `metadata`\n    this.#loadHint ??= convertToLoadHint(getMetadata(entity), this.fieldHint);\n    return entity.em.populate(entity, this.#loadHint).then((loaded) => this.fn(loaded, ctx));\n  }\n\n  // Calc once and cache\n  private deps(meta: EntityMetadata): DefaultDependency[] {\n    return (this.#deps ??= getDefaultDependencies(meta, this.fieldName, this.fieldHint));\n  }\n}\n\ntype DefaultDependency = {\n  meta: EntityMetadata;\n  fieldName: string;\n};\n\n/**\n * Given a `meta` and a nested field hint, return the meta+field tuples included within the hint.\n *\n * I.e. passing `{ author: { firstName: {}, publisher: \"name\" } }` would return `[[Author, \"firstName\"],\n * [Publisher, \"name\"]]`.\n */\nexport function getDefaultDependencies<T extends Entity>(\n  baseMeta: EntityMetadata<T>,\n  baseFieldName: string,\n  baseHint: ReactiveHint<T>,\n): DefaultDependency[] {\n  // Ensure the hint is an `{ ... }`\n  const deps: DefaultDependency[] = [];\n  const todo: [meta: EntityMetadata, hint: ReactiveHint<any>][] = [[baseMeta, normalizeHint(baseHint)]];\n  while (todo.length !== 0) {\n    const [meta, hint] = todo.pop()!;\n    for (const [fieldName, nestedHint] of Object.entries(hint)) {\n      const field = meta.allFields[fieldName];\n      // Super naive circular dependency detection\n      const isSameField = meta === baseMeta && fieldName === baseFieldName;\n      if (isSameField) continue;\n      // If this is an invalid hint, just ignore it, and assume someone else will fail on it\n      if (!field) continue;\n      switch (field.kind) {\n        case \"enum\":\n        case \"primitive\":\n          if (field.default === \"config\" && fieldName in meta.config.__data.asyncDefaults) {\n            deps.push({ meta, fieldName });\n          }\n          break;\n        case \"m2o\":\n          if (field.default === \"config\" && fieldName in meta.config.__data.asyncDefaults) {\n            deps.push({ meta, fieldName });\n          }\n          if (nestedHint) {\n            todo.push([field.otherMetadata(), normalizeHint(nestedHint)]);\n          }\n          break;\n        case \"o2o\":\n        case \"o2m\":\n        case \"m2m\":\n          if (nestedHint) {\n            todo.push([field.otherMetadata(), normalizeHint(nestedHint)]);\n          }\n          break;\n      }\n    }\n  }\n  return deps;\n}\n\n/**\n * This tracks cross-default dependencies that are active within a single `em.flush` loop.\n *\n * I.e. this is not a static \"the Author.firstName in general depends on Publisher.whatever\",\n * it tracks that we're actively inserting 10 new `Author` instances, and their `firstName`\n * default needs to wait until the `Publisher.whatever` fields have their async default\n * calculated.\n *\n * Really this is just a smaller wrapper around a map of `Deferred`s.\n */\nclass DependencyTracker {\n  // Create a map \"entityType -> fieldName -> deferred\"\n  #deferreds = new Map<string, Map<string, Deferred<void>>>();\n\n  constructor(insertsBySubType: Map<EntityMetadata, Entity[]>) {\n    // Seed it with any entities that we're actively inserting (as any dependencies to\n    // entities that aren't even having `setDefault` called can be skipped)\n    for (const meta of [...insertsBySubType.keys()]) {\n      this.#deferreds.set(meta.type, new Map());\n    }\n  }\n\n  hasMaybePending(meta: EntityMetadata): boolean {\n    return this.#deferreds.has(meta.type) ?? false;\n  }\n\n  getDeferred(meta: EntityMetadata, fieldName: string): Deferred<void> {\n    const map = this.#deferreds.get(meta.type) ?? fail(`No deferred check necessary for ${meta.type}.${fieldName}`);\n    let deferred = map.get(fieldName);\n    if (!deferred) {\n      deferred = new Deferred();\n      map.set(fieldName, deferred);\n    }\n    return deferred;\n  }\n}\n\nfunction isRelation(field: Field): boolean {\n  return field.kind !== \"primitive\" && field.kind !== \"enum\";\n}\n"],"mappings":"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"}

package/build/drivers/Driver.d.cts

@@ -9,7 +9,7 @@ import { EntityManager } from "../EntityManager.cjs";
  *
  * @typeParam TX - the connection library-specific `Transaction` type, i.e. `Knex.Transaction`
  */
-interface Driver<TX = unknown> {
+export interface Driver<TX = unknown> {
   /** Executes a low-level `ParsedFindQuery` against the database and returns the rows. */
   executeFind(em: EntityManager, parsed: ParsedFindQuery, settings: {
     limit?: number;
@@ -42,10 +42,9 @@ interface Driver<TX = unknown> {
   };
 }
 /** Raw rows and the database command's affected-row count for mutations or selected-row count for reads. */
-interface DriverQueryResult {
+export interface DriverQueryResult {
   rowCount: number | null;
   rows: any[];
 }
 //#endregion
-export { Driver, DriverQueryResult };
 //# sourceMappingURL=Driver.d.cts.map

package/build/drivers/Driver.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"Driver.d.cts","names":[],"sources":["../../src/drivers/Driver.ts"],"mappings":";;;;;;;;;;;UAWiB,OAAO;;EAEtB,YACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B;;;;;;;EAQH,aAAa,IAAI,eAAe,aAAa,kBAAkB,QAAQ;;;;;;;;EASvE,oBACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B,QAAQ;EAEX,YAAY,GAAG,IAAI,eAAe,KAAK,KAAK,OAAO,QAAQ,KAAK,QAAQ;EAExE,aAAa,IAAI,eAAe,OAAO,eAAe,QAAQ;EAE9D,MAAM,IAAI,eAAe,OAAO,eAAe,OAAO,UAAU,eAAe,eAAe;;EAG9F;IAAkB,gBAAgB;;;;UAInB;EACf;EACA"}
+{"version":3,"file":"Driver.d.cts","names":[],"sources":["../../src/drivers/Driver.ts"],"mappings":";;;;;;;;;;;iBAWiB,OAAO;;EAEtB,YACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B;;;;;;;EAQH,aAAa,IAAI,eAAe,aAAa,kBAAkB,QAAQ;;;;;;;;EASvE,oBACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B,QAAQ;EAEX,YAAY,GAAG,IAAI,eAAe,KAAK,KAAK,OAAO,QAAQ,KAAK,QAAQ;EAExE,aAAa,IAAI,eAAe,OAAO,eAAe,QAAQ;EAE9D,MAAM,IAAI,eAAe,OAAO,eAAe,OAAO,UAAU,eAAe,eAAe;;EAG9F;IAAkB,gBAAgB;;;;iBAInB;EACf;EACA"}

package/build/drivers/Driver.d.mts

@@ -9,7 +9,7 @@ import { EntityManager } from "../EntityManager.mjs";
  *
  * @typeParam TX - the connection library-specific `Transaction` type, i.e. `Knex.Transaction`
  */
-interface Driver<TX = unknown> {
+export interface Driver<TX = unknown> {
   /** Executes a low-level `ParsedFindQuery` against the database and returns the rows. */
   executeFind(em: EntityManager, parsed: ParsedFindQuery, settings: {
     limit?: number;
@@ -42,10 +42,9 @@ interface Driver<TX = unknown> {
   };
 }
 /** Raw rows and the database command's affected-row count for mutations or selected-row count for reads. */
-interface DriverQueryResult {
+export interface DriverQueryResult {
   rowCount: number | null;
   rows: any[];
 }
 //#endregion
-export { Driver, DriverQueryResult };
 //# sourceMappingURL=Driver.d.mts.map

package/build/drivers/Driver.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Driver.d.mts","names":[],"sources":["../../src/drivers/Driver.ts"],"mappings":";;;;;;;;;;;UAWiB,OAAO;;EAEtB,YACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B;;;;;;;EAQH,aAAa,IAAI,eAAe,aAAa,kBAAkB,QAAQ;;;;;;;;EASvE,oBACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B,QAAQ;EAEX,YAAY,GAAG,IAAI,eAAe,KAAK,KAAK,OAAO,QAAQ,KAAK,QAAQ;EAExE,aAAa,IAAI,eAAe,OAAO,eAAe,QAAQ;EAE9D,MAAM,IAAI,eAAe,OAAO,eAAe,OAAO,UAAU,eAAe,eAAe;;EAG9F;IAAkB,gBAAgB;;;;UAInB;EACf;EACA"}
+{"version":3,"file":"Driver.d.mts","names":[],"sources":["../../src/drivers/Driver.ts"],"mappings":";;;;;;;;;;;iBAWiB,OAAO;;EAEtB,YACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B;;;;;;;EAQH,aAAa,IAAI,eAAe,aAAa,kBAAkB,QAAQ;;;;;;;;EASvE,oBACE,IAAI,eACJ,QAAQ,iBACR;IAAY;IAAgB;MAC3B,QAAQ;EAEX,YAAY,GAAG,IAAI,eAAe,KAAK,KAAK,OAAO,QAAQ,KAAK,QAAQ;EAExE,aAAa,IAAI,eAAe,OAAO,eAAe,QAAQ;EAE9D,MAAM,IAAI,eAAe,OAAO,eAAe,OAAO,UAAU,eAAe,eAAe;;EAG9F;IAAkB,gBAAgB;;;;iBAInB;EACf;EACA"}

package/build/drivers/EntityWriter.d.cts

@@ -2,12 +2,12 @@ import { Todo } from "../flush/Todo.cjs";
 import { Entity } from "../Entity.cjs";
 //#region src/drivers/EntityWriter.d.ts
 /** A simplified view of columns, with only the keys necessary to create SQL statements. */
-type OpColumn = {
+export type OpColumn = {
   columnName: string;
   dbType: string;
   isNullableArray?: boolean;
 };
-type InsertOp = {
+export type InsertOp = {
   tableName: string;
   columns: OpColumn[];
   columnValues: any[][];
@@ -20,13 +20,13 @@ type InsertOp = {
  * (with respective pre-update values in the `rows` data), for including in the conditional
  * update clause.
  */
-type UpdateOp = {
+export type UpdateOp = {
   tableName: string;
   columns: OpColumn[];
   columnValues: any[][];
   updatedAt: string | undefined;
 };
-type DeleteOp = {
+export type DeleteOp = {
   tableName: string;
   ids: any[];
 };
@@ -42,7 +42,7 @@ type Ops = {
  * I.e. `INSERT author.favorite_book_id` as `NULL` and then later do an `UPDATE author
  * SET favorite_book_id = 1` after the book has been inserted/we have the id.
  */
-type InsertFixup = {
+export type InsertFixup = {
   entity: Entity;
   tableName: string;
   column: OpColumn;
@@ -60,7 +60,7 @@ type InsertFixup = {
  *
  * But this should let us experiment with knex vs. raw client/etc.
  */
-declare function generateOps(todos: Record<string, Todo>): Ops;
+export declare function generateOps(todos: Record<string, Todo>): Ops;
 //#endregion
-export { DeleteOp, InsertFixup, InsertOp, OpColumn, UpdateOp, generateOps };
+export {};
 //# sourceMappingURL=EntityWriter.d.cts.map

package/build/drivers/EntityWriter.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityWriter.d.cts","names":[],"sources":["../../src/drivers/EntityWriter.ts"],"mappings":";;;;KAiBY;EAAa;EAAoB;EAAgB;;KACjD;EAAa;EAAmB,SAAS;EAAY;;;;;;;;;;KASrD;EACV;EACA,SAAS;EACT;EACA;;KAEU;EAAa;EAAmB;;KAEvC;EAAQ,SAAS;EAAY,SAAS;EAAY,SAAS;;;;;;;;;KASpD;EACV,QAAQ;EACR;EACA,QAAQ;EACR;;;;;;;;;;;;;;iBAec,YAAY,OAAO,eAAe,QAAQ"}
+{"version":3,"file":"EntityWriter.d.cts","names":[],"sources":["../../src/drivers/EntityWriter.ts"],"mappings":";;;;YAiBY;EAAa;EAAoB;EAAgB;;YACjD;EAAa;EAAmB,SAAS;EAAY;;;;;;;;;;YASrD;EACV;EACA,SAAS;EACT;EACA;;YAEU;EAAa;EAAmB;;KAEvC;EAAQ,SAAS;EAAY,SAAS;EAAY,SAAS;;;;;;;;;YASpD;EACV,QAAQ;EACR;EACA,QAAQ;EACR;;;;;;;;;;;;;;wBAec,YAAY,OAAO,eAAe,QAAQ"}

package/build/drivers/EntityWriter.d.mts

@@ -2,12 +2,12 @@ import { Todo } from "../flush/Todo.mjs";
 import { Entity } from "../Entity.mjs";
 //#region src/drivers/EntityWriter.d.ts
 /** A simplified view of columns, with only the keys necessary to create SQL statements. */
-type OpColumn = {
+export type OpColumn = {
   columnName: string;
   dbType: string;
   isNullableArray?: boolean;
 };
-type InsertOp = {
+export type InsertOp = {
   tableName: string;
   columns: OpColumn[];
   columnValues: any[][];
@@ -20,13 +20,13 @@ type InsertOp = {
  * (with respective pre-update values in the `rows` data), for including in the conditional
  * update clause.
  */
-type UpdateOp = {
+export type UpdateOp = {
   tableName: string;
   columns: OpColumn[];
   columnValues: any[][];
   updatedAt: string | undefined;
 };
-type DeleteOp = {
+export type DeleteOp = {
   tableName: string;
   ids: any[];
 };
@@ -42,7 +42,7 @@ type Ops = {
  * I.e. `INSERT author.favorite_book_id` as `NULL` and then later do an `UPDATE author
  * SET favorite_book_id = 1` after the book has been inserted/we have the id.
  */
-type InsertFixup = {
+export type InsertFixup = {
   entity: Entity;
   tableName: string;
   column: OpColumn;
@@ -60,7 +60,7 @@ type InsertFixup = {
  *
  * But this should let us experiment with knex vs. raw client/etc.
  */
-declare function generateOps(todos: Record<string, Todo>): Ops;
+export declare function generateOps(todos: Record<string, Todo>): Ops;
 //#endregion
-export { DeleteOp, InsertFixup, InsertOp, OpColumn, UpdateOp, generateOps };
+export {};
 //# sourceMappingURL=EntityWriter.d.mts.map

package/build/drivers/EntityWriter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityWriter.d.mts","names":[],"sources":["../../src/drivers/EntityWriter.ts"],"mappings":";;;;KAiBY;EAAa;EAAoB;EAAgB;;KACjD;EAAa;EAAmB,SAAS;EAAY;;;;;;;;;;KASrD;EACV;EACA,SAAS;EACT;EACA;;KAEU;EAAa;EAAmB;;KAEvC;EAAQ,SAAS;EAAY,SAAS;EAAY,SAAS;;;;;;;;;KASpD;EACV,QAAQ;EACR;EACA,QAAQ;EACR;;;;;;;;;;;;;;iBAec,YAAY,OAAO,eAAe,QAAQ"}
+{"version":3,"file":"EntityWriter.d.mts","names":[],"sources":["../../src/drivers/EntityWriter.ts"],"mappings":";;;;YAiBY;EAAa;EAAoB;EAAgB;;YACjD;EAAa;EAAmB,SAAS;EAAY;;;;;;;;;;YASrD;EACV;EACA,SAAS;EACT;EACA;;YAEU;EAAa;EAAmB;;KAEvC;EAAQ,SAAS;EAAY,SAAS;EAAY,SAAS;;;;;;;;;YASpD;EACV,QAAQ;EACR;EACA,QAAQ;EACR;;;;;;;;;;;;;;wBAec,YAAY,OAAO,eAAe,QAAQ"}

package/build/drivers/IdAssigner.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"IdAssigner.cjs","names":["#runner","keyToTaggedId"],"sources":["../../src/drivers/IdAssigner.ts"],"sourcesContent":["import * as crypto from \"crypto\";\n\nimport { getInstanceData } from \"src/BaseEntity.ts\";\nimport type { Todo } from \"src/flush/Todo.ts\";\nimport { keyToTaggedId } from \"src/keys.ts\";\n\nexport interface IdAssigner {\n  assignNewIds(todos: Record<string, Todo>): Promise<void>;\n}\n\n/** Super-small/dumb wrapper around maybe-Knex/maybe-postgres.js/maybe-Bun-sql libraries. */\ntype QueryRunner = (sql: string) => Promise<any[]>;\n\n/**\n * Assigns all new entities an id directly from their corresponding sequence generator, instead of via INSERTs.\n *\n * This lets us avoid cyclic issues with some INSERTs having foreign keys to other rows that themselves\n * need to first be INSERTed.\n */\nexport class SequenceIdAssigner implements IdAssigner {\n  #runner: QueryRunner;\n\n  public constructor(runner: QueryRunner) {\n    this.#runner = runner;\n  }\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    const seqStatements: string[] = [];\n    Object.values(todos).forEach((todo) => {\n      // Even if we have INSERTs, the user may have already assigned ids...\n      const needsIds = todo.inserts.filter((e) => e.idMaybe === undefined);\n      if (needsIds.length > 0) {\n        const sequenceName = `${todo.metadata.tableName}_id_seq`;\n        const sql = `select nextval('${sequenceName}') from generate_series(1, ${needsIds.length})`;\n        seqStatements.push(sql);\n      }\n    });\n    if (seqStatements.length > 0) {\n      // There will be 1 per table; 1 single insert should be fine but we might need to batch for super-large schemas?\n      const sql = seqStatements.join(\" UNION ALL \");\n      const result = await this.#runner(sql);\n      let i = 0;\n      Object.values(todos).forEach((todo) => {\n        for (const insert of todo.inserts.filter((e) => e.idMaybe === undefined)) {\n          // Use todo.metadata so that all subtypes get their base type's tag\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, result[i++][\"nextval\"]);\n        }\n      });\n    }\n  }\n}\n\n/**\n * Creates random UUIDs for uuid-based keys in production environments.\n *\n * See {@link TestUuidAssigner} for creating stable-ish ids for tests\n */\nexport class RandomUuidAssigner implements IdAssigner {\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.values(todos).forEach((todo) => {\n      for (const insert of todo.inserts) {\n        getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, crypto.randomUUID());\n      }\n    });\n  }\n}\n\n/**\n * Creates deterministic / stable-ish UUIDs for test suites.\n *\n * We use each entity's tag as the 3rd group of digits, and a per-entity incrementing integer as\n * the 4th group of digits.\n *\n * E.g. a test with two Authors (tag `a`) and three Books (tag `b`) will get these ids:\n *\n * ```\n * 00000000-0000-0000-000a-000000000000\n * 00000000-0000-0000-000a-000000000001\n * 00000000-0000-0000-000b-000000000000\n * 00000000-0000-0000-000b-000000000001\n * 00000000-0000-0000-000b-000000000002\n * ```\n */\nexport class TestUuidAssigner implements IdAssigner {\n  private nextId: Record<string, number> = {};\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.entries(todos).forEach(([, todo]) => {\n      if (todo.inserts.length > 0) {\n        const tag = todo.metadata.tagName.substring(0, 4).padStart(4, \"0\");\n        this.nextId[tag] ??= 0;\n        for (const insert of todo.inserts) {\n          const id = String(this.nextId[tag]++);\n          const uuid = `00000000-0000-0000-${tag}-${id.padStart(12, \"0\")}`;\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, uuid);\n        }\n      }\n    });\n  }\n\n  reset() {\n    this.nextId = {};\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAmBA,IAAa,qBAAb,MAAsD;CACpD;CAEA,YAAmB,QAAqB;EACtC,KAAKA,UAAU;CACjB;CAEA,MAAM,aAAa,OAA4C;EAC7D,MAAM,gBAA0B,CAAC;EACjC,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GAErC,MAAM,WAAW,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS;GACnE,IAAI,SAAS,SAAS,GAAG;IAEvB,MAAM,MAAM,mBAAmB,GADP,KAAK,SAAS,UAAU,SACJ,6BAA6B,SAAS,OAAO;IACzF,cAAc,KAAK,GAAG;GACxB;EACF,CAAC;EACD,IAAI,cAAc,SAAS,GAAG;GAE5B,MAAM,MAAM,cAAc,KAAK,aAAa;GAC5C,MAAM,SAAS,MAAM,KAAKA,QAAQ,GAAG;GACrC,IAAI,IAAI;GACR,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;IACrC,KAAK,MAAM,UAAU,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS,GAErE,mBAAA,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQC,aAAAA,cAAc,KAAK,UAAU,OAAO,IAAI,CAAC,UAAU;GAE5F,CAAC;EACH;CACF;AACF;;;;;;AAOA,IAAa,qBAAb,MAAsD;CACpD,MAAM,aAAa,OAA4C;EAC7D,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GACrC,KAAK,MAAM,UAAU,KAAK,SACxB,mBAAA,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQA,aAAAA,cAAc,KAAK,UAAU,OAAO,WAAW,CAAC;EAEzF,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;AAkBA,IAAa,mBAAb,MAAoD;CAClD,SAAyC,CAAC;CAE1C,MAAM,aAAa,OAA4C;EAC7D,OAAO,QAAQ,KAAK,CAAC,CAAC,SAAS,GAAG,UAAU;GAC1C,IAAI,KAAK,QAAQ,SAAS,GAAG;IAC3B,MAAM,MAAM,KAAK,SAAS,QAAQ,UAAU,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG;IACjE,KAAK,OAAO,SAAS;IACrB,KAAK,MAAM,UAAU,KAAK,SAAS;KAEjC,MAAM,OAAO,sBAAsB,IAAI,GAD5B,OAAO,KAAK,OAAO,IAAI,EACS,CAAC,CAAC,SAAS,IAAI,GAAG;KAC7D,mBAAA,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQA,aAAAA,cAAc,KAAK,UAAU,IAAI;IACxE;GACF;EACF,CAAC;CACH;CAEA,QAAQ;EACN,KAAK,SAAS,CAAC;CACjB;AACF"}
+{"version":3,"file":"IdAssigner.cjs","names":["keyToTaggedId"],"sources":["../../src/drivers/IdAssigner.ts"],"sourcesContent":["import * as crypto from \"crypto\";\n\nimport { getInstanceData } from \"src/BaseEntity.ts\";\nimport type { Todo } from \"src/flush/Todo.ts\";\nimport { keyToTaggedId } from \"src/keys.ts\";\n\nexport interface IdAssigner {\n  assignNewIds(todos: Record<string, Todo>): Promise<void>;\n}\n\n/** Super-small/dumb wrapper around maybe-Knex/maybe-postgres.js/maybe-Bun-sql libraries. */\ntype QueryRunner = (sql: string) => Promise<any[]>;\n\n/**\n * Assigns all new entities an id directly from their corresponding sequence generator, instead of via INSERTs.\n *\n * This lets us avoid cyclic issues with some INSERTs having foreign keys to other rows that themselves\n * need to first be INSERTed.\n */\nexport class SequenceIdAssigner implements IdAssigner {\n  #runner: QueryRunner;\n\n  public constructor(runner: QueryRunner) {\n    this.#runner = runner;\n  }\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    const seqStatements: string[] = [];\n    Object.values(todos).forEach((todo) => {\n      // Even if we have INSERTs, the user may have already assigned ids...\n      const needsIds = todo.inserts.filter((e) => e.idMaybe === undefined);\n      if (needsIds.length > 0) {\n        const sequenceName = `${todo.metadata.tableName}_id_seq`;\n        const sql = `select nextval('${sequenceName}') from generate_series(1, ${needsIds.length})`;\n        seqStatements.push(sql);\n      }\n    });\n    if (seqStatements.length > 0) {\n      // There will be 1 per table; 1 single insert should be fine but we might need to batch for super-large schemas?\n      const sql = seqStatements.join(\" UNION ALL \");\n      const result = await this.#runner(sql);\n      let i = 0;\n      Object.values(todos).forEach((todo) => {\n        for (const insert of todo.inserts.filter((e) => e.idMaybe === undefined)) {\n          // Use todo.metadata so that all subtypes get their base type's tag\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, result[i++][\"nextval\"]);\n        }\n      });\n    }\n  }\n}\n\n/**\n * Creates random UUIDs for uuid-based keys in production environments.\n *\n * See {@link TestUuidAssigner} for creating stable-ish ids for tests\n */\nexport class RandomUuidAssigner implements IdAssigner {\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.values(todos).forEach((todo) => {\n      for (const insert of todo.inserts) {\n        getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, crypto.randomUUID());\n      }\n    });\n  }\n}\n\n/**\n * Creates deterministic / stable-ish UUIDs for test suites.\n *\n * We use each entity's tag as the 3rd group of digits, and a per-entity incrementing integer as\n * the 4th group of digits.\n *\n * E.g. a test with two Authors (tag `a`) and three Books (tag `b`) will get these ids:\n *\n * ```\n * 00000000-0000-0000-000a-000000000000\n * 00000000-0000-0000-000a-000000000001\n * 00000000-0000-0000-000b-000000000000\n * 00000000-0000-0000-000b-000000000001\n * 00000000-0000-0000-000b-000000000002\n * ```\n */\nexport class TestUuidAssigner implements IdAssigner {\n  private nextId: Record<string, number> = {};\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.entries(todos).forEach(([, todo]) => {\n      if (todo.inserts.length > 0) {\n        const tag = todo.metadata.tagName.substring(0, 4).padStart(4, \"0\");\n        this.nextId[tag] ??= 0;\n        for (const insert of todo.inserts) {\n          const id = String(this.nextId[tag]++);\n          const uuid = `00000000-0000-0000-${tag}-${id.padStart(12, \"0\")}`;\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, uuid);\n        }\n      }\n    });\n  }\n\n  reset() {\n    this.nextId = {};\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAmBA,IAAa,qBAAb,MAAsD;CACpD;CAEA,YAAmB,QAAqB;EACtC,KAAK,UAAU;CACjB;CAEA,MAAM,aAAa,OAA4C;EAC7D,MAAM,gBAA0B,CAAC;EACjC,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GAErC,MAAM,WAAW,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS;GACnE,IAAI,SAAS,SAAS,GAAG;IAEvB,MAAM,MAAM,mBAAmB,GADP,KAAK,SAAS,UAAU,SACJ,6BAA6B,SAAS,OAAO;IACzF,cAAc,KAAK,GAAG;GACxB;EACF,CAAC;EACD,IAAI,cAAc,SAAS,GAAG;GAE5B,MAAM,MAAM,cAAc,KAAK,aAAa;GAC5C,MAAM,SAAS,MAAM,KAAK,QAAQ,GAAG;GACrC,IAAI,IAAI;GACR,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;IACrC,KAAK,MAAM,UAAU,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS,GAErE,mBAAA,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQA,aAAAA,cAAc,KAAK,UAAU,OAAO,IAAI,CAAC,UAAU;GAE5F,CAAC;EACH;CACF;AACF;;;;;;AAOA,IAAa,qBAAb,MAAsD;CACpD,MAAM,aAAa,OAA4C;EAC7D,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GACrC,KAAK,MAAM,UAAU,KAAK,SACxB,mBAAA,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQA,aAAAA,cAAc,KAAK,UAAU,OAAO,WAAW,CAAC;EAEzF,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;AAkBA,IAAa,mBAAb,MAAoD;CAClD,SAAyC,CAAC;CAE1C,MAAM,aAAa,OAA4C;EAC7D,OAAO,QAAQ,KAAK,CAAC,CAAC,SAAS,GAAG,UAAU;GAC1C,IAAI,KAAK,QAAQ,SAAS,GAAG;IAC3B,MAAM,MAAM,KAAK,SAAS,QAAQ,UAAU,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG;IACjE,KAAK,OAAO,SAAS;IACrB,KAAK,MAAM,UAAU,KAAK,SAAS;KAEjC,MAAM,OAAO,sBAAsB,IAAI,GAD5B,OAAO,KAAK,OAAO,IAAI,EACS,CAAC,CAAC,SAAS,IAAI,GAAG;KAC7D,mBAAA,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQA,aAAAA,cAAc,KAAK,UAAU,IAAI;IACxE;GACF;EACF,CAAC;CACH;CAEA,QAAQ;EACN,KAAK,SAAS,CAAC;CACjB;AACF"}

package/build/drivers/IdAssigner.d.cts

@@ -1,6 +1,6 @@
 import { Todo } from "../flush/Todo.cjs";
 //#region src/drivers/IdAssigner.d.ts
-interface IdAssigner {
+export interface IdAssigner {
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
 }
 /** Super-small/dumb wrapper around maybe-Knex/maybe-postgres.js/maybe-Bun-sql libraries. */
@@ -11,7 +11,7 @@ type QueryRunner = (sql: string) => Promise<any[]>;
  * This lets us avoid cyclic issues with some INSERTs having foreign keys to other rows that themselves
  * need to first be INSERTed.
  */
-declare class SequenceIdAssigner implements IdAssigner {
+export declare class SequenceIdAssigner implements IdAssigner {
   #private;
   constructor(runner: QueryRunner);
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
@@ -21,7 +21,7 @@ declare class SequenceIdAssigner implements IdAssigner {
  *
  * See {@link TestUuidAssigner} for creating stable-ish ids for tests
  */
-declare class RandomUuidAssigner implements IdAssigner {
+export declare class RandomUuidAssigner implements IdAssigner {
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
 }
 /**
@@ -40,11 +40,11 @@ declare class RandomUuidAssigner implements IdAssigner {
  * 00000000-0000-0000-000b-000000000002
  * ```
  */
-declare class TestUuidAssigner implements IdAssigner {
+export declare class TestUuidAssigner implements IdAssigner {
   private nextId;
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
   reset(): void;
 }
 //#endregion
-export { IdAssigner, RandomUuidAssigner, SequenceIdAssigner, TestUuidAssigner };
+export {};
 //# sourceMappingURL=IdAssigner.d.cts.map

package/build/drivers/IdAssigner.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"IdAssigner.d.cts","names":[],"sources":["../../src/drivers/IdAssigner.ts"],"mappings":";;UAMiB;EACf,aAAa,OAAO,eAAe,QAAQ;;;KAIxC,eAAe,gBAAgB;;;;;;;cAQvB,8BAA8B;;EAGzC,YAAmB,QAAQ;EAIrB,aAAa,OAAO,eAAe,QAAQ;;;;;;;cA+BtC,8BAA8B;EACnC,aAAa,OAAO,eAAe,QAAQ;;;;;;;;;;;;;;;;;;cAyBtC,4BAA4B;UAC/B;EAEF,aAAa,OAAO,eAAe,QAAQ;EAcjD"}
+{"version":3,"file":"IdAssigner.d.cts","names":[],"sources":["../../src/drivers/IdAssigner.ts"],"mappings":";;iBAMiB;EACf,aAAa,OAAO,eAAe,QAAQ;;;KAIxC,eAAe,gBAAgB;;;;;;;qBAQvB,8BAA8B;;EAGzC,YAAmB,QAAQ;EAIrB,aAAa,OAAO,eAAe,QAAQ;;;;;;;qBA+BtC,8BAA8B;EACnC,aAAa,OAAO,eAAe,QAAQ;;;;;;;;;;;;;;;;;;qBAyBtC,4BAA4B;UAC/B;EAEF,aAAa,OAAO,eAAe,QAAQ;EAcjD"}

package/build/drivers/IdAssigner.d.mts

@@ -1,6 +1,6 @@
 import { Todo } from "../flush/Todo.mjs";
 //#region src/drivers/IdAssigner.d.ts
-interface IdAssigner {
+export interface IdAssigner {
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
 }
 /** Super-small/dumb wrapper around maybe-Knex/maybe-postgres.js/maybe-Bun-sql libraries. */
@@ -11,7 +11,7 @@ type QueryRunner = (sql: string) => Promise<any[]>;
  * This lets us avoid cyclic issues with some INSERTs having foreign keys to other rows that themselves
  * need to first be INSERTed.
  */
-declare class SequenceIdAssigner implements IdAssigner {
+export declare class SequenceIdAssigner implements IdAssigner {
   #private;
   constructor(runner: QueryRunner);
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
@@ -21,7 +21,7 @@ declare class SequenceIdAssigner implements IdAssigner {
  *
  * See {@link TestUuidAssigner} for creating stable-ish ids for tests
  */
-declare class RandomUuidAssigner implements IdAssigner {
+export declare class RandomUuidAssigner implements IdAssigner {
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
 }
 /**
@@ -40,11 +40,11 @@ declare class RandomUuidAssigner implements IdAssigner {
  * 00000000-0000-0000-000b-000000000002
  * ```
  */
-declare class TestUuidAssigner implements IdAssigner {
+export declare class TestUuidAssigner implements IdAssigner {
   private nextId;
   assignNewIds(todos: Record<string, Todo>): Promise<void>;
   reset(): void;
 }
 //#endregion
-export { IdAssigner, RandomUuidAssigner, SequenceIdAssigner, TestUuidAssigner };
+export {};
 //# sourceMappingURL=IdAssigner.d.mts.map

package/build/drivers/IdAssigner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"IdAssigner.d.mts","names":[],"sources":["../../src/drivers/IdAssigner.ts"],"mappings":";;UAMiB;EACf,aAAa,OAAO,eAAe,QAAQ;;;KAIxC,eAAe,gBAAgB;;;;;;;cAQvB,8BAA8B;;EAGzC,YAAmB,QAAQ;EAIrB,aAAa,OAAO,eAAe,QAAQ;;;;;;;cA+BtC,8BAA8B;EACnC,aAAa,OAAO,eAAe,QAAQ;;;;;;;;;;;;;;;;;;cAyBtC,4BAA4B;UAC/B;EAEF,aAAa,OAAO,eAAe,QAAQ;EAcjD"}
+{"version":3,"file":"IdAssigner.d.mts","names":[],"sources":["../../src/drivers/IdAssigner.ts"],"mappings":";;iBAMiB;EACf,aAAa,OAAO,eAAe,QAAQ;;;KAIxC,eAAe,gBAAgB;;;;;;;qBAQvB,8BAA8B;;EAGzC,YAAmB,QAAQ;EAIrB,aAAa,OAAO,eAAe,QAAQ;;;;;;;qBA+BtC,8BAA8B;EACnC,aAAa,OAAO,eAAe,QAAQ;;;;;;;;;;;;;;;;;;qBAyBtC,4BAA4B;UAC/B;EAEF,aAAa,OAAO,eAAe,QAAQ;EAcjD"}

package/build/drivers/IdAssigner.js.map

@@ -1 +1 @@
-{"version":3,"file":"IdAssigner.js","names":["#runner"],"sources":["../../src/drivers/IdAssigner.ts"],"sourcesContent":["import * as crypto from \"crypto\";\n\nimport { getInstanceData } from \"src/BaseEntity.ts\";\nimport type { Todo } from \"src/flush/Todo.ts\";\nimport { keyToTaggedId } from \"src/keys.ts\";\n\nexport interface IdAssigner {\n  assignNewIds(todos: Record<string, Todo>): Promise<void>;\n}\n\n/** Super-small/dumb wrapper around maybe-Knex/maybe-postgres.js/maybe-Bun-sql libraries. */\ntype QueryRunner = (sql: string) => Promise<any[]>;\n\n/**\n * Assigns all new entities an id directly from their corresponding sequence generator, instead of via INSERTs.\n *\n * This lets us avoid cyclic issues with some INSERTs having foreign keys to other rows that themselves\n * need to first be INSERTed.\n */\nexport class SequenceIdAssigner implements IdAssigner {\n  #runner: QueryRunner;\n\n  public constructor(runner: QueryRunner) {\n    this.#runner = runner;\n  }\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    const seqStatements: string[] = [];\n    Object.values(todos).forEach((todo) => {\n      // Even if we have INSERTs, the user may have already assigned ids...\n      const needsIds = todo.inserts.filter((e) => e.idMaybe === undefined);\n      if (needsIds.length > 0) {\n        const sequenceName = `${todo.metadata.tableName}_id_seq`;\n        const sql = `select nextval('${sequenceName}') from generate_series(1, ${needsIds.length})`;\n        seqStatements.push(sql);\n      }\n    });\n    if (seqStatements.length > 0) {\n      // There will be 1 per table; 1 single insert should be fine but we might need to batch for super-large schemas?\n      const sql = seqStatements.join(\" UNION ALL \");\n      const result = await this.#runner(sql);\n      let i = 0;\n      Object.values(todos).forEach((todo) => {\n        for (const insert of todo.inserts.filter((e) => e.idMaybe === undefined)) {\n          // Use todo.metadata so that all subtypes get their base type's tag\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, result[i++][\"nextval\"]);\n        }\n      });\n    }\n  }\n}\n\n/**\n * Creates random UUIDs for uuid-based keys in production environments.\n *\n * See {@link TestUuidAssigner} for creating stable-ish ids for tests\n */\nexport class RandomUuidAssigner implements IdAssigner {\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.values(todos).forEach((todo) => {\n      for (const insert of todo.inserts) {\n        getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, crypto.randomUUID());\n      }\n    });\n  }\n}\n\n/**\n * Creates deterministic / stable-ish UUIDs for test suites.\n *\n * We use each entity's tag as the 3rd group of digits, and a per-entity incrementing integer as\n * the 4th group of digits.\n *\n * E.g. a test with two Authors (tag `a`) and three Books (tag `b`) will get these ids:\n *\n * ```\n * 00000000-0000-0000-000a-000000000000\n * 00000000-0000-0000-000a-000000000001\n * 00000000-0000-0000-000b-000000000000\n * 00000000-0000-0000-000b-000000000001\n * 00000000-0000-0000-000b-000000000002\n * ```\n */\nexport class TestUuidAssigner implements IdAssigner {\n  private nextId: Record<string, number> = {};\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.entries(todos).forEach(([, todo]) => {\n      if (todo.inserts.length > 0) {\n        const tag = todo.metadata.tagName.substring(0, 4).padStart(4, \"0\");\n        this.nextId[tag] ??= 0;\n        for (const insert of todo.inserts) {\n          const id = String(this.nextId[tag]++);\n          const uuid = `00000000-0000-0000-${tag}-${id.padStart(12, \"0\")}`;\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, uuid);\n        }\n      }\n    });\n  }\n\n  reset() {\n    this.nextId = {};\n  }\n}\n"],"mappings":";;;;;;;;;;AAmBA,IAAa,qBAAb,MAAsD;CACpD;CAEA,YAAmB,QAAqB;EACtC,KAAKA,UAAU;CACjB;CAEA,MAAM,aAAa,OAA4C;EAC7D,MAAM,gBAA0B,CAAC;EACjC,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GAErC,MAAM,WAAW,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS;GACnE,IAAI,SAAS,SAAS,GAAG;IAEvB,MAAM,MAAM,mBAAmB,GADP,KAAK,SAAS,UAAU,SACJ,6BAA6B,SAAS,OAAO;IACzF,cAAc,KAAK,GAAG;GACxB;EACF,CAAC;EACD,IAAI,cAAc,SAAS,GAAG;GAE5B,MAAM,MAAM,cAAc,KAAK,aAAa;GAC5C,MAAM,SAAS,MAAM,KAAKA,QAAQ,GAAG;GACrC,IAAI,IAAI;GACR,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;IACrC,KAAK,MAAM,UAAU,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS,GAErE,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQ,cAAc,KAAK,UAAU,OAAO,IAAI,CAAC,UAAU;GAE5F,CAAC;EACH;CACF;AACF;;;;;;AAOA,IAAa,qBAAb,MAAsD;CACpD,MAAM,aAAa,OAA4C;EAC7D,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GACrC,KAAK,MAAM,UAAU,KAAK,SACxB,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQ,cAAc,KAAK,UAAU,OAAO,WAAW,CAAC;EAEzF,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;AAkBA,IAAa,mBAAb,MAAoD;CAClD,SAAyC,CAAC;CAE1C,MAAM,aAAa,OAA4C;EAC7D,OAAO,QAAQ,KAAK,CAAC,CAAC,SAAS,GAAG,UAAU;GAC1C,IAAI,KAAK,QAAQ,SAAS,GAAG;IAC3B,MAAM,MAAM,KAAK,SAAS,QAAQ,UAAU,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG;IACjE,KAAK,OAAO,SAAS;IACrB,KAAK,MAAM,UAAU,KAAK,SAAS;KAEjC,MAAM,OAAO,sBAAsB,IAAI,GAD5B,OAAO,KAAK,OAAO,IAAI,EACS,CAAC,CAAC,SAAS,IAAI,GAAG;KAC7D,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQ,cAAc,KAAK,UAAU,IAAI;IACxE;GACF;EACF,CAAC;CACH;CAEA,QAAQ;EACN,KAAK,SAAS,CAAC;CACjB;AACF"}
+{"version":3,"file":"IdAssigner.js","names":[],"sources":["../../src/drivers/IdAssigner.ts"],"sourcesContent":["import * as crypto from \"crypto\";\n\nimport { getInstanceData } from \"src/BaseEntity.ts\";\nimport type { Todo } from \"src/flush/Todo.ts\";\nimport { keyToTaggedId } from \"src/keys.ts\";\n\nexport interface IdAssigner {\n  assignNewIds(todos: Record<string, Todo>): Promise<void>;\n}\n\n/** Super-small/dumb wrapper around maybe-Knex/maybe-postgres.js/maybe-Bun-sql libraries. */\ntype QueryRunner = (sql: string) => Promise<any[]>;\n\n/**\n * Assigns all new entities an id directly from their corresponding sequence generator, instead of via INSERTs.\n *\n * This lets us avoid cyclic issues with some INSERTs having foreign keys to other rows that themselves\n * need to first be INSERTed.\n */\nexport class SequenceIdAssigner implements IdAssigner {\n  #runner: QueryRunner;\n\n  public constructor(runner: QueryRunner) {\n    this.#runner = runner;\n  }\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    const seqStatements: string[] = [];\n    Object.values(todos).forEach((todo) => {\n      // Even if we have INSERTs, the user may have already assigned ids...\n      const needsIds = todo.inserts.filter((e) => e.idMaybe === undefined);\n      if (needsIds.length > 0) {\n        const sequenceName = `${todo.metadata.tableName}_id_seq`;\n        const sql = `select nextval('${sequenceName}') from generate_series(1, ${needsIds.length})`;\n        seqStatements.push(sql);\n      }\n    });\n    if (seqStatements.length > 0) {\n      // There will be 1 per table; 1 single insert should be fine but we might need to batch for super-large schemas?\n      const sql = seqStatements.join(\" UNION ALL \");\n      const result = await this.#runner(sql);\n      let i = 0;\n      Object.values(todos).forEach((todo) => {\n        for (const insert of todo.inserts.filter((e) => e.idMaybe === undefined)) {\n          // Use todo.metadata so that all subtypes get their base type's tag\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, result[i++][\"nextval\"]);\n        }\n      });\n    }\n  }\n}\n\n/**\n * Creates random UUIDs for uuid-based keys in production environments.\n *\n * See {@link TestUuidAssigner} for creating stable-ish ids for tests\n */\nexport class RandomUuidAssigner implements IdAssigner {\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.values(todos).forEach((todo) => {\n      for (const insert of todo.inserts) {\n        getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, crypto.randomUUID());\n      }\n    });\n  }\n}\n\n/**\n * Creates deterministic / stable-ish UUIDs for test suites.\n *\n * We use each entity's tag as the 3rd group of digits, and a per-entity incrementing integer as\n * the 4th group of digits.\n *\n * E.g. a test with two Authors (tag `a`) and three Books (tag `b`) will get these ids:\n *\n * ```\n * 00000000-0000-0000-000a-000000000000\n * 00000000-0000-0000-000a-000000000001\n * 00000000-0000-0000-000b-000000000000\n * 00000000-0000-0000-000b-000000000001\n * 00000000-0000-0000-000b-000000000002\n * ```\n */\nexport class TestUuidAssigner implements IdAssigner {\n  private nextId: Record<string, number> = {};\n\n  async assignNewIds(todos: Record<string, Todo>): Promise<void> {\n    Object.entries(todos).forEach(([, todo]) => {\n      if (todo.inserts.length > 0) {\n        const tag = todo.metadata.tagName.substring(0, 4).padStart(4, \"0\");\n        this.nextId[tag] ??= 0;\n        for (const insert of todo.inserts) {\n          const id = String(this.nextId[tag]++);\n          const uuid = `00000000-0000-0000-${tag}-${id.padStart(12, \"0\")}`;\n          getInstanceData(insert).data[\"id\"] = keyToTaggedId(todo.metadata, uuid);\n        }\n      }\n    });\n  }\n\n  reset() {\n    this.nextId = {};\n  }\n}\n"],"mappings":";;;;;;;;;;AAmBA,IAAa,qBAAb,MAAsD;CACpD;CAEA,YAAmB,QAAqB;EACtC,KAAK,UAAU;CACjB;CAEA,MAAM,aAAa,OAA4C;EAC7D,MAAM,gBAA0B,CAAC;EACjC,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GAErC,MAAM,WAAW,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS;GACnE,IAAI,SAAS,SAAS,GAAG;IAEvB,MAAM,MAAM,mBAAmB,GADP,KAAK,SAAS,UAAU,SACJ,6BAA6B,SAAS,OAAO;IACzF,cAAc,KAAK,GAAG;GACxB;EACF,CAAC;EACD,IAAI,cAAc,SAAS,GAAG;GAE5B,MAAM,MAAM,cAAc,KAAK,aAAa;GAC5C,MAAM,SAAS,MAAM,KAAK,QAAQ,GAAG;GACrC,IAAI,IAAI;GACR,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;IACrC,KAAK,MAAM,UAAU,KAAK,QAAQ,QAAQ,MAAM,EAAE,YAAY,KAAA,CAAS,GAErE,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQ,cAAc,KAAK,UAAU,OAAO,IAAI,CAAC,UAAU;GAE5F,CAAC;EACH;CACF;AACF;;;;;;AAOA,IAAa,qBAAb,MAAsD;CACpD,MAAM,aAAa,OAA4C;EAC7D,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,SAAS;GACrC,KAAK,MAAM,UAAU,KAAK,SACxB,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQ,cAAc,KAAK,UAAU,OAAO,WAAW,CAAC;EAEzF,CAAC;CACH;AACF;;;;;;;;;;;;;;;;;AAkBA,IAAa,mBAAb,MAAoD;CAClD,SAAyC,CAAC;CAE1C,MAAM,aAAa,OAA4C;EAC7D,OAAO,QAAQ,KAAK,CAAC,CAAC,SAAS,GAAG,UAAU;GAC1C,IAAI,KAAK,QAAQ,SAAS,GAAG;IAC3B,MAAM,MAAM,KAAK,SAAS,QAAQ,UAAU,GAAG,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG;IACjE,KAAK,OAAO,SAAS;IACrB,KAAK,MAAM,UAAU,KAAK,SAAS;KAEjC,MAAM,OAAO,sBAAsB,IAAI,GAD5B,OAAO,KAAK,OAAO,IAAI,EACS,CAAC,CAAC,SAAS,IAAI,GAAG;KAC7D,gBAAgB,MAAM,CAAC,CAAC,KAAK,QAAQ,cAAc,KAAK,UAAU,IAAI;IACxE;GACF;EACF,CAAC;CACH;CAEA,QAAQ;EACN,KAAK,SAAS,CAAC;CACjB;AACF"}

package/build/drivers/driverApi.d.cts

@@ -4,7 +4,7 @@ import { buildCteSql } from "../queries/find/buildFindQuery.cjs";
 import { buildValuesCte } from "../dataloaders/findDataLoader.cjs";
 import { getRuntimeConfig } from "../runtimeConfig.cjs";
 //#region src/drivers/driverApi.d.ts
-declare const driverApi: {
+export declare const driverApi: {
   buildValuesCte: typeof buildValuesCte;
   generateOps: typeof generateOps;
   buildCteSql: typeof buildCteSql;
@@ -12,11 +12,10 @@ declare const driverApi: {
   batched: typeof batched;
   cleanSql: typeof cleanSql;
 };
-type driverApi = {
+export type driverApi = {
   DeleteOp: DeleteOp;
   UpdateOp: UpdateOp;
   InsertOp: InsertOp;
 };
 //#endregion
-export { driverApi };
 //# sourceMappingURL=driverApi.d.cts.map

package/build/drivers/driverApi.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"driverApi.d.cts","names":[],"sources":["../../src/drivers/driverApi.ts"],"mappings":";;;;;;cAMa;;;;;;;;KASD;EACV,UAAU;EACV,UAAU;EACV,UAAU"}
+{"version":3,"file":"driverApi.d.cts","names":[],"sources":["../../src/drivers/driverApi.ts"],"mappings":";;;;;;qBAMa;;;;;;;;YASD;EACV,UAAU;EACV,UAAU;EACV,UAAU"}

package/build/drivers/driverApi.d.mts

@@ -4,7 +4,7 @@ import { buildCteSql } from "../queries/find/buildFindQuery.mjs";
 import { buildValuesCte } from "../dataloaders/findDataLoader.mjs";
 import { getRuntimeConfig } from "../runtimeConfig.mjs";
 //#region src/drivers/driverApi.d.ts
-declare const driverApi: {
+export declare const driverApi: {
   buildValuesCte: typeof buildValuesCte;
   generateOps: typeof generateOps;
   buildCteSql: typeof buildCteSql;
@@ -12,11 +12,10 @@ declare const driverApi: {
   batched: typeof batched;
   cleanSql: typeof cleanSql;
 };
-type driverApi = {
+export type driverApi = {
   DeleteOp: DeleteOp;
   UpdateOp: UpdateOp;
   InsertOp: InsertOp;
 };
 //#endregion
-export { driverApi };
 //# sourceMappingURL=driverApi.d.mts.map

package/build/drivers/driverApi.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"driverApi.d.mts","names":[],"sources":["../../src/drivers/driverApi.ts"],"mappings":";;;;;;cAMa;;;;;;;;KASD;EACV,UAAU;EACV,UAAU;EACV,UAAU"}
+{"version":3,"file":"driverApi.d.mts","names":[],"sources":["../../src/drivers/driverApi.ts"],"mappings":";;;;;;qBAMa;;;;;;;;YASD;EACV,UAAU;EACV,UAAU;EACV,UAAU"}

package/build/fields.d.cts

@@ -7,11 +7,11 @@ import { Entity } from "./Entity.cjs";
  * We skip any typing like `fieldName: keyof T` because this method should only be
  * called by trusted codegen anyway.
  */
-declare function getField(entity: Entity, fieldName: string): any;
+export declare function getField(entity: Entity, fieldName: string): any;
 /** Returns whether `fieldName` is a field/column on `entity` that can be changed. */
-declare function isChangeableField(entity: Entity, fieldName: string): boolean;
+export declare function isChangeableField(entity: Entity, fieldName: string): boolean;
 /** Returns whether `fieldName` has been set, even if it's undefined, on `entity`. */
-declare function isFieldSet(entity: Entity, fieldName: string): boolean;
+export declare function isFieldSet(entity: Entity, fieldName: string): boolean;
 /**
  * Sets the current value of `fieldName`, this is an internal method that should
  * only be called by the code-generated setters.
@@ -21,9 +21,8 @@ declare function isFieldSet(entity: Entity, fieldName: string): boolean;
  *
  * Returns `true` if the value was changed, or `false` if it was a noop.
  */
-declare function setField(entity: Entity, fieldName: string, newValue: any): boolean;
-declare function equalArrays(a: any[], b: any[]): boolean;
-declare function equal(a: any, b: any): boolean;
+export declare function setField(entity: Entity, fieldName: string, newValue: any): boolean;
+export declare function equalArrays(a: any[], b: any[]): boolean;
+export declare function equal(a: any, b: any): boolean;
 //#endregion
-export { equal, equalArrays, getField, isChangeableField, isFieldSet, setField };
 //# sourceMappingURL=fields.d.cts.map

package/build/fields.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"fields.d.cts","names":[],"sources":["../src/fields.ts"],"mappings":";;;;;;;;;iBAegB,SAAS,QAAQ,QAAQ;;iBAoBzB,kBAAkB,QAAQ,QAAQ;;iBAKlC,WAAW,QAAQ,QAAQ;;;;;;;;;;iBAmB3B,SAAS,QAAQ,QAAQ,mBAAmB;iBAmH5C,YAAY,UAAU;iBAMtB,MAAM,QAAQ"}
+{"version":3,"file":"fields.d.cts","names":[],"sources":["../src/fields.ts"],"mappings":";;;;;;;;;wBAegB,SAAS,QAAQ,QAAQ;;wBAoBzB,kBAAkB,QAAQ,QAAQ;;wBAKlC,WAAW,QAAQ,QAAQ;;;;;;;;;;wBAmB3B,SAAS,QAAQ,QAAQ,mBAAmB;wBAmH5C,YAAY,UAAU;wBAMtB,MAAM,QAAQ"}

package/build/fields.d.mts

@@ -7,11 +7,11 @@ import { Entity } from "./Entity.mjs";
  * We skip any typing like `fieldName: keyof T` because this method should only be
  * called by trusted codegen anyway.
  */
-declare function getField(entity: Entity, fieldName: string): any;
+export declare function getField(entity: Entity, fieldName: string): any;
 /** Returns whether `fieldName` is a field/column on `entity` that can be changed. */
-declare function isChangeableField(entity: Entity, fieldName: string): boolean;
+export declare function isChangeableField(entity: Entity, fieldName: string): boolean;
 /** Returns whether `fieldName` has been set, even if it's undefined, on `entity`. */
-declare function isFieldSet(entity: Entity, fieldName: string): boolean;
+export declare function isFieldSet(entity: Entity, fieldName: string): boolean;
 /**
  * Sets the current value of `fieldName`, this is an internal method that should
  * only be called by the code-generated setters.
@@ -21,9 +21,8 @@ declare function isFieldSet(entity: Entity, fieldName: string): boolean;
  *
  * Returns `true` if the value was changed, or `false` if it was a noop.
  */
-declare function setField(entity: Entity, fieldName: string, newValue: any): boolean;
-declare function equalArrays(a: any[], b: any[]): boolean;
-declare function equal(a: any, b: any): boolean;
+export declare function setField(entity: Entity, fieldName: string, newValue: any): boolean;
+export declare function equalArrays(a: any[], b: any[]): boolean;
+export declare function equal(a: any, b: any): boolean;
 //#endregion
-export { equal, equalArrays, getField, isChangeableField, isFieldSet, setField };
 //# sourceMappingURL=fields.d.mts.map

package/build/fields.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"fields.d.mts","names":[],"sources":["../src/fields.ts"],"mappings":";;;;;;;;;iBAegB,SAAS,QAAQ,QAAQ;;iBAoBzB,kBAAkB,QAAQ,QAAQ;;iBAKlC,WAAW,QAAQ,QAAQ;;;;;;;;;;iBAmB3B,SAAS,QAAQ,QAAQ,mBAAmB;iBAmH5C,YAAY,UAAU;iBAMtB,MAAM,QAAQ"}
+{"version":3,"file":"fields.d.mts","names":[],"sources":["../src/fields.ts"],"mappings":";;;;;;;;;wBAegB,SAAS,QAAQ,QAAQ;;wBAoBzB,kBAAkB,QAAQ,QAAQ;;wBAKlC,WAAW,QAAQ,QAAQ;;;;;;;;;;wBAmB3B,SAAS,QAAQ,QAAQ,mBAAmB;wBAmH5C,YAAY,UAAU;wBAMtB,MAAM,QAAQ"}

package/build/flush/FlushLock.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"FlushLock.cjs","names":["AsyncLocalStorage","#isFlushing","#flushSecret"],"sources":["../../src/flush/FlushLock.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"async_hooks\";\n\n/** A marker to prevent setter calls during `flush` calls. */\nconst currentFlushSecret = new AsyncLocalStorage<{ flushSecret: number }>();\n\n/**\n * Prevents entities being mutated mid-flush.\n *\n * The `flush` process does a dirty check + SQL flush and generally doesn't want\n * entities to re-dirtied after it's done the initial dirty check. So we'd like\n * to prevent all setter calls while `flush` is running.\n *\n * That said, lifecycle code like hooks actually can make setter calls b/c `flush`\n * invokes them at a specific point in its process.\n *\n * We solve this by using node's `AsyncLocalStorage` to mark certain callbacks (promise\n * handlers) as blessed / invoked-from-`flush`-itself, and they are allowed to call setters,\n * but any external callers (i.e. application code) will be rejected.\n */\nexport class FlushLock {\n  #flushSecret: number = 0;\n  #isFlushing: boolean = false;\n\n  /** This will begin any non-hook restrictions on writing to entities. */\n  startLock(): void {\n    if (this.#isFlushing) {\n      throw new Error(\"Cannot flush while another flush is already in progress\");\n    }\n    this.#isFlushing = true;\n  }\n\n  releaseLock(): void {\n    this.#isFlushing = false;\n  }\n\n  /** Any writes that happen from `fn`, despite flush being locked, will be allowed. */\n  allowWrites(fn: () => Promise<void>): Promise<void> {\n    return currentFlushSecret.run({ flushSecret: this.#flushSecret }, () =>\n      fn().then(() => {\n        this.#flushSecret += 1;\n      }),\n    );\n  }\n\n  /** Blows up if writes are locked, i.e. we're flushing and the caller is not within an `allowWrites` block. */\n  checkWritesAllowed(): void {\n    if (this.#isFlushing) {\n      const { flushSecret } = currentFlushSecret.getStore() || {};\n      if (flushSecret === undefined) {\n        throw new Error(`Cannot mutate an entity during an em.flush outside of a entity hook or from afterCommit`);\n      } else if (flushSecret !== this.#flushSecret) {\n        throw new Error(`Attempting to reuse a hook context outside its flush loop`);\n      }\n    }\n  }\n\n  get isFlushing(): boolean {\n    return this.#isFlushing;\n  }\n}\n"],"mappings":";;;AAGA,MAAM,qBAAqB,0BAAIA,EAAAA,CAAAA,kBAA2C;;;;;;;;;;;;;;;AAgB1E,IAAa,YAAb,MAAuB;CACrB,eAAuB;CACvB,cAAuB;;CAGvB,YAAkB;EAChB,IAAI,KAAKC,aACP,MAAM,IAAI,MAAM,yDAAyD;EAE3E,KAAKA,cAAc;CACrB;CAEA,cAAoB;EAClB,KAAKA,cAAc;CACrB;;CAGA,YAAY,IAAwC;EAClD,OAAO,mBAAmB,IAAI,EAAE,aAAa,KAAKC,aAAa,SAC7D,GAAG,CAAC,CAAC,WAAW;GACd,KAAKA,gBAAgB;EACvB,CAAC,CACH;CACF;;CAGA,qBAA2B;EACzB,IAAI,KAAKD,aAAa;GACpB,MAAM,EAAE,gBAAgB,mBAAmB,SAAS,KAAK,CAAC;GAC1D,IAAI,gBAAgB,KAAA,GAClB,MAAM,IAAI,MAAM,yFAAyF;QACpG,IAAI,gBAAgB,KAAKC,cAC9B,MAAM,IAAI,MAAM,2DAA2D;EAE/E;CACF;CAEA,IAAI,aAAsB;EACxB,OAAO,KAAKD;CACd;AACF"}
+{"version":3,"file":"FlushLock.cjs","names":["AsyncLocalStorage"],"sources":["../../src/flush/FlushLock.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"async_hooks\";\n\n/** A marker to prevent setter calls during `flush` calls. */\nconst currentFlushSecret = new AsyncLocalStorage<{ flushSecret: number }>();\n\n/**\n * Prevents entities being mutated mid-flush.\n *\n * The `flush` process does a dirty check + SQL flush and generally doesn't want\n * entities to re-dirtied after it's done the initial dirty check. So we'd like\n * to prevent all setter calls while `flush` is running.\n *\n * That said, lifecycle code like hooks actually can make setter calls b/c `flush`\n * invokes them at a specific point in its process.\n *\n * We solve this by using node's `AsyncLocalStorage` to mark certain callbacks (promise\n * handlers) as blessed / invoked-from-`flush`-itself, and they are allowed to call setters,\n * but any external callers (i.e. application code) will be rejected.\n */\nexport class FlushLock {\n  #flushSecret: number = 0;\n  #isFlushing: boolean = false;\n\n  /** This will begin any non-hook restrictions on writing to entities. */\n  startLock(): void {\n    if (this.#isFlushing) {\n      throw new Error(\"Cannot flush while another flush is already in progress\");\n    }\n    this.#isFlushing = true;\n  }\n\n  releaseLock(): void {\n    this.#isFlushing = false;\n  }\n\n  /** Any writes that happen from `fn`, despite flush being locked, will be allowed. */\n  allowWrites(fn: () => Promise<void>): Promise<void> {\n    return currentFlushSecret.run({ flushSecret: this.#flushSecret }, () =>\n      fn().then(() => {\n        this.#flushSecret += 1;\n      }),\n    );\n  }\n\n  /** Blows up if writes are locked, i.e. we're flushing and the caller is not within an `allowWrites` block. */\n  checkWritesAllowed(): void {\n    if (this.#isFlushing) {\n      const { flushSecret } = currentFlushSecret.getStore() || {};\n      if (flushSecret === undefined) {\n        throw new Error(`Cannot mutate an entity during an em.flush outside of a entity hook or from afterCommit`);\n      } else if (flushSecret !== this.#flushSecret) {\n        throw new Error(`Attempting to reuse a hook context outside its flush loop`);\n      }\n    }\n  }\n\n  get isFlushing(): boolean {\n    return this.#isFlushing;\n  }\n}\n"],"mappings":";;;AAGA,MAAM,qBAAqB,0BAAIA,EAAAA,CAAAA,kBAA2C;;;;;;;;;;;;;;;AAgB1E,IAAa,YAAb,MAAuB;CACrB,eAAuB;CACvB,cAAuB;;CAGvB,YAAkB;EAChB,IAAI,KAAK,aACP,MAAM,IAAI,MAAM,yDAAyD;EAE3E,KAAK,cAAc;CACrB;CAEA,cAAoB;EAClB,KAAK,cAAc;CACrB;;CAGA,YAAY,IAAwC;EAClD,OAAO,mBAAmB,IAAI,EAAE,aAAa,KAAK,aAAa,SAC7D,GAAG,CAAC,CAAC,WAAW;GACd,KAAK,gBAAgB;EACvB,CAAC,CACH;CACF;;CAGA,qBAA2B;EACzB,IAAI,KAAK,aAAa;GACpB,MAAM,EAAE,gBAAgB,mBAAmB,SAAS,KAAK,CAAC;GAC1D,IAAI,gBAAgB,KAAA,GAClB,MAAM,IAAI,MAAM,yFAAyF;QACpG,IAAI,gBAAgB,KAAK,cAC9B,MAAM,IAAI,MAAM,2DAA2D;EAE/E;CACF;CAEA,IAAI,aAAsB;EACxB,OAAO,KAAK;CACd;AACF"}

package/build/flush/FlushLock.d.cts

@@ -13,7 +13,7 @@
  * handlers) as blessed / invoked-from-`flush`-itself, and they are allowed to call setters,
  * but any external callers (i.e. application code) will be rejected.
  */
-declare class FlushLock {
+export declare class FlushLock {
   #private;
   /** This will begin any non-hook restrictions on writing to entities. */
   startLock(): void;
@@ -25,5 +25,4 @@ declare class FlushLock {
   get isFlushing(): boolean;
 }
 //#endregion
-export { FlushLock };
 //# sourceMappingURL=FlushLock.d.cts.map

package/build/flush/FlushLock.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"FlushLock.d.cts","names":[],"sources":["../../src/flush/FlushLock.ts"],"mappings":";;;;;;;;;;;;;;;cAmBa;;;EAKX;EAOA;;EAKA,YAAY,UAAU,gBAAgB;;EAStC;MAWI"}
+{"version":3,"file":"FlushLock.d.cts","names":[],"sources":["../../src/flush/FlushLock.ts"],"mappings":";;;;;;;;;;;;;;;qBAmBa;;;EAKX;EAOA;;EAKA,YAAY,UAAU,gBAAgB;;EAStC;MAWI"}

package/build/flush/FlushLock.d.mts

@@ -13,7 +13,7 @@
  * handlers) as blessed / invoked-from-`flush`-itself, and they are allowed to call setters,
  * but any external callers (i.e. application code) will be rejected.
  */
-declare class FlushLock {
+export declare class FlushLock {
   #private;
   /** This will begin any non-hook restrictions on writing to entities. */
   startLock(): void;
@@ -25,5 +25,4 @@ declare class FlushLock {
   get isFlushing(): boolean;
 }
 //#endregion
-export { FlushLock };
 //# sourceMappingURL=FlushLock.d.mts.map

package/build/flush/FlushLock.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"FlushLock.d.mts","names":[],"sources":["../../src/flush/FlushLock.ts"],"mappings":";;;;;;;;;;;;;;;cAmBa;;;EAKX;EAOA;;EAKA,YAAY,UAAU,gBAAgB;;EAStC;MAWI"}
+{"version":3,"file":"FlushLock.d.mts","names":[],"sources":["../../src/flush/FlushLock.ts"],"mappings":";;;;;;;;;;;;;;;qBAmBa;;;EAKX;EAOA;;EAKA,YAAY,UAAU,gBAAgB;;EAStC;MAWI"}

package/build/flush/FlushLock.js.map

@@ -1 +1 @@
-{"version":3,"file":"FlushLock.js","names":["#isFlushing","#flushSecret"],"sources":["../../src/flush/FlushLock.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"async_hooks\";\n\n/** A marker to prevent setter calls during `flush` calls. */\nconst currentFlushSecret = new AsyncLocalStorage<{ flushSecret: number }>();\n\n/**\n * Prevents entities being mutated mid-flush.\n *\n * The `flush` process does a dirty check + SQL flush and generally doesn't want\n * entities to re-dirtied after it's done the initial dirty check. So we'd like\n * to prevent all setter calls while `flush` is running.\n *\n * That said, lifecycle code like hooks actually can make setter calls b/c `flush`\n * invokes them at a specific point in its process.\n *\n * We solve this by using node's `AsyncLocalStorage` to mark certain callbacks (promise\n * handlers) as blessed / invoked-from-`flush`-itself, and they are allowed to call setters,\n * but any external callers (i.e. application code) will be rejected.\n */\nexport class FlushLock {\n  #flushSecret: number = 0;\n  #isFlushing: boolean = false;\n\n  /** This will begin any non-hook restrictions on writing to entities. */\n  startLock(): void {\n    if (this.#isFlushing) {\n      throw new Error(\"Cannot flush while another flush is already in progress\");\n    }\n    this.#isFlushing = true;\n  }\n\n  releaseLock(): void {\n    this.#isFlushing = false;\n  }\n\n  /** Any writes that happen from `fn`, despite flush being locked, will be allowed. */\n  allowWrites(fn: () => Promise<void>): Promise<void> {\n    return currentFlushSecret.run({ flushSecret: this.#flushSecret }, () =>\n      fn().then(() => {\n        this.#flushSecret += 1;\n      }),\n    );\n  }\n\n  /** Blows up if writes are locked, i.e. we're flushing and the caller is not within an `allowWrites` block. */\n  checkWritesAllowed(): void {\n    if (this.#isFlushing) {\n      const { flushSecret } = currentFlushSecret.getStore() || {};\n      if (flushSecret === undefined) {\n        throw new Error(`Cannot mutate an entity during an em.flush outside of a entity hook or from afterCommit`);\n      } else if (flushSecret !== this.#flushSecret) {\n        throw new Error(`Attempting to reuse a hook context outside its flush loop`);\n      }\n    }\n  }\n\n  get isFlushing(): boolean {\n    return this.#isFlushing;\n  }\n}\n"],"mappings":";;;AAGA,MAAM,qBAAqB,IAAI,kBAA2C;;;;;;;;;;;;;;;AAgB1E,IAAa,YAAb,MAAuB;CACrB,eAAuB;CACvB,cAAuB;;CAGvB,YAAkB;EAChB,IAAI,KAAKA,aACP,MAAM,IAAI,MAAM,yDAAyD;EAE3E,KAAKA,cAAc;CACrB;CAEA,cAAoB;EAClB,KAAKA,cAAc;CACrB;;CAGA,YAAY,IAAwC;EAClD,OAAO,mBAAmB,IAAI,EAAE,aAAa,KAAKC,aAAa,SAC7D,GAAG,CAAC,CAAC,WAAW;GACd,KAAKA,gBAAgB;EACvB,CAAC,CACH;CACF;;CAGA,qBAA2B;EACzB,IAAI,KAAKD,aAAa;GACpB,MAAM,EAAE,gBAAgB,mBAAmB,SAAS,KAAK,CAAC;GAC1D,IAAI,gBAAgB,KAAA,GAClB,MAAM,IAAI,MAAM,yFAAyF;QACpG,IAAI,gBAAgB,KAAKC,cAC9B,MAAM,IAAI,MAAM,2DAA2D;EAE/E;CACF;CAEA,IAAI,aAAsB;EACxB,OAAO,KAAKD;CACd;AACF"}
+{"version":3,"file":"FlushLock.js","names":[],"sources":["../../src/flush/FlushLock.ts"],"sourcesContent":["import { AsyncLocalStorage } from \"async_hooks\";\n\n/** A marker to prevent setter calls during `flush` calls. */\nconst currentFlushSecret = new AsyncLocalStorage<{ flushSecret: number }>();\n\n/**\n * Prevents entities being mutated mid-flush.\n *\n * The `flush` process does a dirty check + SQL flush and generally doesn't want\n * entities to re-dirtied after it's done the initial dirty check. So we'd like\n * to prevent all setter calls while `flush` is running.\n *\n * That said, lifecycle code like hooks actually can make setter calls b/c `flush`\n * invokes them at a specific point in its process.\n *\n * We solve this by using node's `AsyncLocalStorage` to mark certain callbacks (promise\n * handlers) as blessed / invoked-from-`flush`-itself, and they are allowed to call setters,\n * but any external callers (i.e. application code) will be rejected.\n */\nexport class FlushLock {\n  #flushSecret: number = 0;\n  #isFlushing: boolean = false;\n\n  /** This will begin any non-hook restrictions on writing to entities. */\n  startLock(): void {\n    if (this.#isFlushing) {\n      throw new Error(\"Cannot flush while another flush is already in progress\");\n    }\n    this.#isFlushing = true;\n  }\n\n  releaseLock(): void {\n    this.#isFlushing = false;\n  }\n\n  /** Any writes that happen from `fn`, despite flush being locked, will be allowed. */\n  allowWrites(fn: () => Promise<void>): Promise<void> {\n    return currentFlushSecret.run({ flushSecret: this.#flushSecret }, () =>\n      fn().then(() => {\n        this.#flushSecret += 1;\n      }),\n    );\n  }\n\n  /** Blows up if writes are locked, i.e. we're flushing and the caller is not within an `allowWrites` block. */\n  checkWritesAllowed(): void {\n    if (this.#isFlushing) {\n      const { flushSecret } = currentFlushSecret.getStore() || {};\n      if (flushSecret === undefined) {\n        throw new Error(`Cannot mutate an entity during an em.flush outside of a entity hook or from afterCommit`);\n      } else if (flushSecret !== this.#flushSecret) {\n        throw new Error(`Attempting to reuse a hook context outside its flush loop`);\n      }\n    }\n  }\n\n  get isFlushing(): boolean {\n    return this.#isFlushing;\n  }\n}\n"],"mappings":";;;AAGA,MAAM,qBAAqB,IAAI,kBAA2C;;;;;;;;;;;;;;;AAgB1E,IAAa,YAAb,MAAuB;CACrB,eAAuB;CACvB,cAAuB;;CAGvB,YAAkB;EAChB,IAAI,KAAK,aACP,MAAM,IAAI,MAAM,yDAAyD;EAE3E,KAAK,cAAc;CACrB;CAEA,cAAoB;EAClB,KAAK,cAAc;CACrB;;CAGA,YAAY,IAAwC;EAClD,OAAO,mBAAmB,IAAI,EAAE,aAAa,KAAK,aAAa,SAC7D,GAAG,CAAC,CAAC,WAAW;GACd,KAAK,gBAAgB;EACvB,CAAC,CACH;CACF;;CAGA,qBAA2B;EACzB,IAAI,KAAK,aAAa;GACpB,MAAM,EAAE,gBAAgB,mBAAmB,SAAS,KAAK,CAAC;GAC1D,IAAI,gBAAgB,KAAA,GAClB,MAAM,IAAI,MAAM,yFAAyF;QACpG,IAAI,gBAAgB,KAAK,cAC9B,MAAM,IAAI,MAAM,2DAA2D;EAE/E;CACF;CAEA,IAAI,aAAsB;EACxB,OAAO,KAAK;CACd;AACF"}