joist-core 2.3.0-next.97 → 2.3.0-next.99

package/build/temporalMappers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"temporalMappers.js","names":[],"sources":["../src/temporalMappers.ts"],"sourcesContent":["import { type CustomSerde } from \"./serde.ts\";\nimport { type Temporal, maybeRequireTemporal } from \"./temporal.ts\";\nimport { fail } from \"./utils.ts\";\n\nconst { Temporal: t } = maybeRequireTemporal() ?? {};\nconst temporalNotAvailable = {\n  fromDb: () => fail(\"Temporal not available\"),\n  toDb: () => fail(\"Temporal not available\"),\n};\n\n/**\n * Converts Postgres `DATE` to/from Temporal.PlainDate.\n *\n * `fromDb` accepts either pg's text form (classic/knex text queries, json_agg preloads) or an\n * already-constructed `PlainDate` (lazy binary queries decode wire bytes -> Temporal directly).\n */\nexport const plainDateMapper: CustomSerde<Temporal.PlainDate, string> = t\n  ? {\n      fromDb: (value: string | Temporal.PlainDate) => (value instanceof t.PlainDate ? value : t.PlainDate.from(value)),\n      toDb: (p) => p.toString(),\n    }\n  : temporalNotAvailable;\n\n/** Converts Postgres `TIME` to/from Temporal.PlainTime; `fromDb` also passes binary-decoded instances through. */\nexport const plainTimeMapper: CustomSerde<Temporal.PlainTime, string> = t\n  ? {\n      fromDb: (value: string | Temporal.PlainTime) => (value instanceof t.PlainTime ? value : t.PlainTime.from(value)),\n      toDb: (pt) => pt.toString(),\n    }\n  : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMP` / `TIMESTAMP WITHOUT TIME ZONE` to/from Temporal.PlainDateTime;\n * `fromDb` also passes binary-decoded instances through.\n */\nexport const plainDateTimeMapper: CustomSerde<Temporal.PlainDateTime, string> = t\n  ? {\n      // Text values look like `2018-01-01 10:00:00`\n      fromDb: (value: string | Temporal.PlainDateTime) =>\n        value instanceof t.PlainDateTime ? value : t.PlainDateTime.from(value),\n      toDb: (p) => p.toString(),\n    }\n  : temporalNotAvailable;\n\n/**\n * Converts Postgres `TIMESTAMPTZ`, `TIMESTAMPTZ WITH TIME ZONE` to/from Temporal.ZonedDateTime.\n *\n * Specifically, Postgres uses ISO 8601, which Temporal supports as well, except that PG ouputs a space instead of `T`\n * between the date/time for output.\n *\n * Additionally, `Temporal.ZonedDateTime.from` expects a time zone literal name to be supplied as part of the string,\n * but this is not stored by postgres.\n *\n * As such, we parse the offset and append it to string passed to `from` as the time zone.  This means that if we did a\n * round trip of generating a db value then parsing it, then it may not strictly equal the original zdt.\n *\n * Finally, PG stores dates as UTC and converts them to its local time zone for output, so we could get any offset\n * theoretically.  If, somehow, we don't get an offset, then we assume UTC.\n */\nexport const zonedDateTimeMapper: CustomSerde<Temporal.ZonedDateTime, string> = t\n  ? {\n      // Produce a ZDT from a PG output like \"2021-01-01 12:00:00-05:00\"; binary-decoded\n      // instances (lazy queries construct ZonedDateTimes directly) pass through\n      fromDb: (value: string | Temporal.ZonedDateTime) => {\n        if (typeof value !== \"string\") return value;\n        const [offset] = value.match(/([+-]\\d{2}(?::?\\d{2})?)$/) ?? [];\n        return t.ZonedDateTime.from(`${value}[${!offset || /^\\+00(:?00)?$/.test(offset) ? \"UTC\" : offset}]`);\n      },\n      // Match a PG `TIMESTAMPTZ` input format, i.e. \"2021-01-01T12:00:00-05:00\"\n      toDb: (zdt) => zdt.toString({ timeZoneName: \"never\" }),\n    }\n  : temporalNotAvailable;\n"],"mappings":";;;;AAIA,MAAM,EAAE,UAAU,MAAM,qBAAqB,KAAK,CAAC;AACnD,MAAM,uBAAuB;CAC3B,cAAc,KAAK,wBAAwB;CAC3C,YAAY,KAAK,wBAAwB;AAC3C;;;;;;;AAQA,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;AAGJ,MAAa,kBAA2D,IACpE;CACE,SAAS,UAAwC,iBAAiB,EAAE,YAAY,QAAQ,EAAE,UAAU,KAAK,KAAK;CAC9G,OAAO,OAAO,GAAG,SAAS;AAC5B,IACA;;;;;AAMJ,MAAa,sBAAmE,IAC5E;CAEE,SAAS,UACP,iBAAiB,EAAE,gBAAgB,QAAQ,EAAE,cAAc,KAAK,KAAK;CACvE,OAAO,MAAM,EAAE,SAAS;AAC1B,IACA;;;;;;;;;;;;;;;;AAiBJ,MAAa,sBAAmE,IAC5E;CAGE,SAAS,UAA2C;EAClD,IAAI,OAAO,UAAU,UAAU,OAAO;EACtC,MAAM,CAAC,UAAU,MAAM,MAAM,0BAA0B,KAAK,CAAC;EAC7D,OAAO,EAAE,cAAc,KAAK,GAAG,MAAM,GAAG,CAAC,UAAU,gBAAgB,KAAK,MAAM,IAAI,QAAQ,OAAO,EAAE;CACrG;CAEA,OAAO,QAAQ,IAAI,SAAS,EAAE,cAAc,QAAQ,CAAC;AACvD,IACA"}

package/build/unnest.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"unnest.cjs","names":[],"sources":["../src/unnest.ts"],"sourcesContent":["import { type OpColumn } from \"./drivers/EntityWriter.ts\";\nimport type { ParsedCteClause } from \"./queries/find/QueryParser.ts\";\n\n/**\n * Creates a CTE named `alias` that bulk-injects the `columnValues` into a SQL query.\n *\n * I.e. `columns = [first_name, last_name]` means columnValues would be all first names,\n * then all last names, i.e.`[[\"f1\",\"f2\"], [\"l1\",\"l2\"]]`.\n *\n * Note that `columnValues` will be mutated if any array columns need to be made rectangular.\n */\nexport function buildUnnestCte(alias: string, columns: OpColumn[], columnValues: any[][]): ParsedCteClause {\n  // Make any arrays-of-arrays rectangular by filling them with nulls\n  ensureRectangularArraySizes(columns, columnValues);\n  // Use unnest or unnest_arrays depending on whether the column is an array column\n  const selects = columns.map((c) => {\n    if (c.dbType.endsWith(\"[]\")) {\n      if (c.isNullableArray) {\n        return `unnest_arrays(?::${c.dbType}[], true)`;\n      } else {\n        return `unnest_arrays(?::${c.dbType}[])`;\n      }\n    } else {\n      return `unnest(?::${c.dbType}[])`;\n    }\n  });\n  return {\n    alias,\n    columns,\n    query: { kind: \"raw\", sql: `SELECT ${selects.join(\", \")}`, bindings: columnValues },\n  };\n}\n\nexport function ensureRectangularArraySizes(columns: OpColumn[], columnValues: any[][]): void {\n  for (let i = 0; i < columns.length; i++) {\n    const column = columns[i];\n    if (column.dbType.endsWith(\"[]\")) {\n      const values = columnValues[i];\n      const fillTo = findArrayMaxSize(values);\n      for (let j = 0; j < values.length; j++) {\n        values[j] = fillArrayWithNulls(column, values[j], fillTo);\n      }\n    }\n  }\n}\n\nfunction findArrayMaxSize(columnValues: readonly any[][]): number {\n  let max = 1; // postgres really doesn't like `{{}}` so always send at least 1 element\n  for (let i = 0; i < columnValues.length; i++) max = Math.max(max, columnValues[i]?.length ?? 0);\n  return max;\n}\n\n// Because postgres array-of-arrays must be rectangular, we fill all arrays up the same max size\n// to put on the wire, and then later strip the padded nulls during the unnest_arrays call.\nfunction fillArrayWithNulls(c: OpColumn, array: any[] | null, maxSize: number): any[] {\n  const wasNull = array === null;\n  const result = array ? [...array] : [];\n  const nullsToAdd = Math.max(0, maxSize - (array?.length ?? 0));\n  for (let i = 0; i < nullsToAdd; i++) result.push(null);\n  // Add our unset marker\n  if (c.isNullableArray) result.unshift(wasNull ? null : notNullMarker(c));\n  return result;\n}\n\nfunction notNullMarker(c: OpColumn): any {\n  // Should probably push this into an OpColumn.notNullMarker value\n  if (c.dbType.startsWith(\"varchar\") || c.dbType.startsWith(\"character\") || c.dbType.startsWith(\"text\")) {\n    return \"\";\n  } else if (c.dbType.startsWith(\"int\")) {\n    return 1;\n  } else if (c.dbType.startsWith(\"date\")) {\n    return new Date(); // maybe something temporal?\n  } else if (c.dbType.startsWith(\"timestamp\")) {\n    return new Date(); // maybe something temporal?\n  } else {\n    throw new Error(\"Unhandled nullable array column type \" + c.dbType);\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,eAAe,OAAe,SAAqB,cAAwC;CAEzG,4BAA4B,SAAS,YAAY;CAajD,OAAO;EACL;EACA;EACA,OAAO;GAAE,MAAM;GAAO,KAAK,UAdb,QAAQ,KAAK,MAAM;IACjC,IAAI,EAAE,OAAO,SAAS,IAAI,GAAG;KAC3B,IAAI,EAAE,iBACJ,OAAO,oBAAoB,EAAE,OAAO;UAEpC,OAAO,oBAAoB,EAAE,OAAO;IAExC,OACE,OAAO,aAAa,EAAE,OAAO;GAEjC,CAI6C,CAAC,CAAC,KAAK,IAAI;GAAK,UAAU;EAAa;CACpF;AACF;AAEA,SAAgB,4BAA4B,SAAqB,cAA6B;CAC5F,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,SAAS,QAAQ;EACvB,IAAI,OAAO,OAAO,SAAS,IAAI,GAAG;GAChC,MAAM,SAAS,aAAa;GAC5B,MAAM,SAAS,iBAAiB,MAAM;GACtC,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KACjC,OAAO,KAAK,mBAAmB,QAAQ,OAAO,IAAI,MAAM;EAE5D;CACF;AACF;AAEA,SAAS,iBAAiB,cAAwC;CAChE,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,KAAK,aAAa,EAAE,EAAE,UAAU,CAAC;CAC9F,OAAO;AACT;AAIA,SAAS,mBAAmB,GAAa,OAAqB,SAAwB;CACpF,MAAM,UAAU,UAAU;CAC1B,MAAM,SAAS,QAAQ,CAAC,GAAG,KAAK,IAAI,CAAC;CACrC,MAAM,aAAa,KAAK,IAAI,GAAG,WAAW,OAAO,UAAU,EAAE;CAC7D,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAAK,OAAO,KAAK,IAAI;CAErD,IAAI,EAAE,iBAAiB,OAAO,QAAQ,UAAU,OAAO,cAAc,CAAC,CAAC;CACvE,OAAO;AACT;AAEA,SAAS,cAAc,GAAkB;CAEvC,IAAI,EAAE,OAAO,WAAW,SAAS,KAAK,EAAE,OAAO,WAAW,WAAW,KAAK,EAAE,OAAO,WAAW,MAAM,GAClG,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,KAAK,GAClC,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,MAAM,GACnC,uBAAO,IAAI,KAAK;MACX,IAAI,EAAE,OAAO,WAAW,WAAW,GACxC,uBAAO,IAAI,KAAK;MAEhB,MAAM,IAAI,MAAM,0CAA0C,EAAE,MAAM;AAEtE"}

package/build/unnest.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unnest.d.cts","names":[],"sources":["../src/unnest.ts"],"mappings":";;;;;;;;;;;iBAWgB,eAAe,eAAe,SAAS,YAAY,wBAAwB;iBAsB3E,4BAA4B,SAAS,YAAY"}

package/build/unnest.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unnest.d.mts","names":[],"sources":["../src/unnest.ts"],"mappings":";;;;;;;;;;;iBAWgB,eAAe,eAAe,SAAS,YAAY,wBAAwB;iBAsB3E,4BAA4B,SAAS,YAAY"}

package/build/unnest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"unnest.js","names":[],"sources":["../src/unnest.ts"],"sourcesContent":["import { type OpColumn } from \"./drivers/EntityWriter.ts\";\nimport type { ParsedCteClause } from \"./queries/find/QueryParser.ts\";\n\n/**\n * Creates a CTE named `alias` that bulk-injects the `columnValues` into a SQL query.\n *\n * I.e. `columns = [first_name, last_name]` means columnValues would be all first names,\n * then all last names, i.e.`[[\"f1\",\"f2\"], [\"l1\",\"l2\"]]`.\n *\n * Note that `columnValues` will be mutated if any array columns need to be made rectangular.\n */\nexport function buildUnnestCte(alias: string, columns: OpColumn[], columnValues: any[][]): ParsedCteClause {\n  // Make any arrays-of-arrays rectangular by filling them with nulls\n  ensureRectangularArraySizes(columns, columnValues);\n  // Use unnest or unnest_arrays depending on whether the column is an array column\n  const selects = columns.map((c) => {\n    if (c.dbType.endsWith(\"[]\")) {\n      if (c.isNullableArray) {\n        return `unnest_arrays(?::${c.dbType}[], true)`;\n      } else {\n        return `unnest_arrays(?::${c.dbType}[])`;\n      }\n    } else {\n      return `unnest(?::${c.dbType}[])`;\n    }\n  });\n  return {\n    alias,\n    columns,\n    query: { kind: \"raw\", sql: `SELECT ${selects.join(\", \")}`, bindings: columnValues },\n  };\n}\n\nexport function ensureRectangularArraySizes(columns: OpColumn[], columnValues: any[][]): void {\n  for (let i = 0; i < columns.length; i++) {\n    const column = columns[i];\n    if (column.dbType.endsWith(\"[]\")) {\n      const values = columnValues[i];\n      const fillTo = findArrayMaxSize(values);\n      for (let j = 0; j < values.length; j++) {\n        values[j] = fillArrayWithNulls(column, values[j], fillTo);\n      }\n    }\n  }\n}\n\nfunction findArrayMaxSize(columnValues: readonly any[][]): number {\n  let max = 1; // postgres really doesn't like `{{}}` so always send at least 1 element\n  for (let i = 0; i < columnValues.length; i++) max = Math.max(max, columnValues[i]?.length ?? 0);\n  return max;\n}\n\n// Because postgres array-of-arrays must be rectangular, we fill all arrays up the same max size\n// to put on the wire, and then later strip the padded nulls during the unnest_arrays call.\nfunction fillArrayWithNulls(c: OpColumn, array: any[] | null, maxSize: number): any[] {\n  const wasNull = array === null;\n  const result = array ? [...array] : [];\n  const nullsToAdd = Math.max(0, maxSize - (array?.length ?? 0));\n  for (let i = 0; i < nullsToAdd; i++) result.push(null);\n  // Add our unset marker\n  if (c.isNullableArray) result.unshift(wasNull ? null : notNullMarker(c));\n  return result;\n}\n\nfunction notNullMarker(c: OpColumn): any {\n  // Should probably push this into an OpColumn.notNullMarker value\n  if (c.dbType.startsWith(\"varchar\") || c.dbType.startsWith(\"character\") || c.dbType.startsWith(\"text\")) {\n    return \"\";\n  } else if (c.dbType.startsWith(\"int\")) {\n    return 1;\n  } else if (c.dbType.startsWith(\"date\")) {\n    return new Date(); // maybe something temporal?\n  } else if (c.dbType.startsWith(\"timestamp\")) {\n    return new Date(); // maybe something temporal?\n  } else {\n    throw new Error(\"Unhandled nullable array column type \" + c.dbType);\n  }\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,eAAe,OAAe,SAAqB,cAAwC;CAEzG,4BAA4B,SAAS,YAAY;CAajD,OAAO;EACL;EACA;EACA,OAAO;GAAE,MAAM;GAAO,KAAK,UAdb,QAAQ,KAAK,MAAM;IACjC,IAAI,EAAE,OAAO,SAAS,IAAI,GAAG;KAC3B,IAAI,EAAE,iBACJ,OAAO,oBAAoB,EAAE,OAAO;UAEpC,OAAO,oBAAoB,EAAE,OAAO;IAExC,OACE,OAAO,aAAa,EAAE,OAAO;GAEjC,CAI6C,CAAC,CAAC,KAAK,IAAI;GAAK,UAAU;EAAa;CACpF;AACF;AAEA,SAAgB,4BAA4B,SAAqB,cAA6B;CAC5F,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACvC,MAAM,SAAS,QAAQ;EACvB,IAAI,OAAO,OAAO,SAAS,IAAI,GAAG;GAChC,MAAM,SAAS,aAAa;GAC5B,MAAM,SAAS,iBAAiB,MAAM;GACtC,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KACjC,OAAO,KAAK,mBAAmB,QAAQ,OAAO,IAAI,MAAM;EAE5D;CACF;AACF;AAEA,SAAS,iBAAiB,cAAwC;CAChE,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,MAAM,KAAK,IAAI,KAAK,aAAa,EAAE,EAAE,UAAU,CAAC;CAC9F,OAAO;AACT;AAIA,SAAS,mBAAmB,GAAa,OAAqB,SAAwB;CACpF,MAAM,UAAU,UAAU;CAC1B,MAAM,SAAS,QAAQ,CAAC,GAAG,KAAK,IAAI,CAAC;CACrC,MAAM,aAAa,KAAK,IAAI,GAAG,WAAW,OAAO,UAAU,EAAE;CAC7D,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAAK,OAAO,KAAK,IAAI;CAErD,IAAI,EAAE,iBAAiB,OAAO,QAAQ,UAAU,OAAO,cAAc,CAAC,CAAC;CACvE,OAAO;AACT;AAEA,SAAS,cAAc,GAAkB;CAEvC,IAAI,EAAE,OAAO,WAAW,SAAS,KAAK,EAAE,OAAO,WAAW,WAAW,KAAK,EAAE,OAAO,WAAW,MAAM,GAClG,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,KAAK,GAClC,OAAO;MACF,IAAI,EAAE,OAAO,WAAW,MAAM,GACnC,uBAAO,IAAI,KAAK;MACX,IAAI,EAAE,OAAO,WAAW,WAAW,GACxC,uBAAO,IAAI,KAAK;MAEhB,MAAM,IAAI,MAAM,0CAA0C,EAAE,MAAM;AAEtE"}

package/build/withLoaded.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"withLoaded.cjs","names":["maybePromiseThen","isRelation","isProperty","isReactiveField","isReactiveGetter","isAsyncReactiveField","isLoadedReference","isLoadedCollection","isLoadedProperty","isLoadedAsyncReactiveField","fail"],"sources":["../src/withLoaded.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"./loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"./relations/AsyncReactiveField.ts\";\nimport {\n  type LoadedCollection,\n  type LoadedProperty,\n  type LoadedReadOnlyCollection,\n  type LoadedReference,\n  type PolymorphicReference,\n  type Property,\n  type Relation,\n  isAsyncReactiveField,\n  isLoadedCollection,\n  isLoadedProperty,\n  isLoadedReference,\n  isProperty,\n  isReactiveField,\n  isReactiveGetter,\n  isRelation,\n} from \"./relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"./utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n  [\n    K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n  ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n    ? L[K] extends LoadedReference<T, U, N>\n      ? U | N\n      : L[K]\n    : L[K] extends LoadedReference<T, infer U, never>\n      ? U\n      : L[K] extends LoadedReference<T, infer U, undefined>\n        ? U | undefined\n        : L[K] extends LoadedCollection<T, infer U>\n          ? U[]\n          : L[K] extends LoadedReadOnlyCollection<T, infer U>\n            ? // leaving out `readonly U[]` until we're ready to switch\n              U[]\n            : L[K] extends LoadedProperty<T, infer V>\n              ? V\n              : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n  return maybePromiseThen(\n    loadedOrPromise,\n    (loaded) =>\n      new Proxy(loaded, {\n        get: (target, prop) => {\n          const value: any = (target as any)[prop];\n          if (\n            isRelation(value) ||\n            isProperty(value) ||\n            isReactiveField(value) ||\n            isReactiveGetter(value) ||\n            isAsyncReactiveField(value)\n          ) {\n            return isLoadedReference(value) ||\n              isLoadedCollection(value) ||\n              isLoadedProperty(value) ||\n              isReactiveField(value) ||\n              isLoadedAsyncReactiveField(value) ||\n              isReactiveGetter(value)\n              ? value.get\n              : fail(`${target}.${String(prop)} is not loaded`);\n          } else if (value instanceof StubbedRelation) {\n            return value.get;\n          } else {\n            return value;\n          }\n        },\n      }) as WithLoaded<T, H, L>,\n  );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n  assertLoaded<T, H>(entity, hint);\n  return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n *   get: () => new StubbedRelation([]),\n *  });\n * ```\n */\nexport class StubbedRelation {\n  constructor(private value: any) {}\n\n  get get() {\n    return this.value;\n  }\n\n  get isLoaded() {\n    return true;\n  }\n\n  load() {\n    return this.get;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAOA,cAAAA,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACEC,2BAAAA,WAAW,KAAK,KAChBC,8BAAAA,WAAW,KAAK,KAChBC,gCAAAA,gBAAgB,KAAK,KACrBC,iCAAAA,iBAAiB,KAAK,KACtBC,qCAAAA,qBAAqB,KAAK,GAE1B,OAAOC,4BAAAA,kBAAkB,KAAK,KAC5BC,6BAAAA,mBAAmB,KAAK,KACxBC,8BAAAA,iBAAiB,KAAK,KACtBL,gCAAAA,gBAAgB,KAAK,KACrBM,qCAAAA,2BAA2B,KAAK,KAChCL,iCAAAA,iBAAiB,KAAK,IACpB,MAAM,MACNM,cAAAA,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,kBAAA,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}

package/build/withLoaded.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withLoaded.d.cts","names":[],"sources":["../src/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/withLoaded.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"withLoaded.d.mts","names":[],"sources":["../src/withLoaded.ts"],"mappings":";;;;;;;;;;KAwBY,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,SAEhF,WAAW,KAAK,EAAE;EAAa;IAAiB,IAAI,EAAE,WAAW,qBAAqB,6BAA6B,IAClH,EAAE,WAAW,qBAAqB,SAAS,SAAS,KACnD,EAAE,WAAW,gBAAgB,GAAG,GAAG,KACjC,IAAI,IACJ,EAAE,KACJ,EAAE,WAAW,gBAAgB,SAAS,YACpC,IACA,EAAE,WAAW,gBAAgB,SAAS,gBACpC,gBACA,EAAE,WAAW,iBAAiB,SAAS,KACrC,MACA,EAAE,WAAW,yBAAyB,SAAS,KAE7C,MACA,EAAE,WAAW,eAAe,SAAS,KACnC,IACA,EAAE;;;;;;;;;;;;;;;;;;;;;iBAuBF,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,SAAS,QAAQ,KAChB,QAAQ,WAAW,GAAG,GAAG;iBACZ,WAAW,UAAU,QAAQ,UAAU,SAAS,IAAI,UAAU,OAAO,GAAG,IACtF,QAAQ,IACP,WAAW,GAAG,GAAG;iBAmCJ,iBAAiB,UAAU,cAAc,UAAU,SAAS,IAC1E,QAAQ,GACR,MAAM,IACL,WAAW,GAAG,GAAG,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;cAwBjB;UACS;EAApB,YAAoB;MAEhB;MAIA;EAIJ"}

package/build/withLoaded.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"withLoaded.js","names":[],"sources":["../src/withLoaded.ts"],"sourcesContent":["import { type Entity } from \"./Entity.ts\";\nimport { type LoadHint, type Loaded, assertLoaded } from \"./loadHints.ts\";\nimport { isLoadedAsyncReactiveField } from \"./relations/AsyncReactiveField.ts\";\nimport {\n  type LoadedCollection,\n  type LoadedProperty,\n  type LoadedReadOnlyCollection,\n  type LoadedReference,\n  type PolymorphicReference,\n  type Property,\n  type Relation,\n  isAsyncReactiveField,\n  isLoadedCollection,\n  isLoadedProperty,\n  isLoadedReference,\n  isProperty,\n  isReactiveField,\n  isReactiveGetter,\n  isRelation,\n} from \"./relations/index.ts\";\nimport { type MaybePromise, fail, maybePromiseThen } from \"./utils.ts\";\n\n// This type seems is overly complex for references, but it's necessary in order to ensure that potential\n// undefined references are properly propagated and that polymorphic references don't overwhelm the type system.\nexport type WithLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>> = {\n  [\n    K in keyof L as L[K] extends { get: unknown } ? K : L[K] extends Relation<any, any> | Property<any, any> ? never : K\n  ]: L[K] extends PolymorphicReference<T, infer U, infer N>\n    ? L[K] extends LoadedReference<T, U, N>\n      ? U | N\n      : L[K]\n    : L[K] extends LoadedReference<T, infer U, never>\n      ? U\n      : L[K] extends LoadedReference<T, infer U, undefined>\n        ? U | undefined\n        : L[K] extends LoadedCollection<T, infer U>\n          ? U[]\n          : L[K] extends LoadedReadOnlyCollection<T, infer U>\n            ? // leaving out `readonly U[]` until we're ready to switch\n              U[]\n            : L[K] extends LoadedProperty<T, infer V>\n              ? V\n              : L[K];\n};\n\n/**\n * Allows destructuring against entities to more succinctly access loaded relations.\n *\n * ```typescript\n * // Instead of\n * const author = book.author.get;\n * // Use withLoaded\n * const { author } = withLoaded(book);\n * ```\n *\n * Granted, when accessing one property, this is not a win, but if you're accessing\n * ~3-4 separate loaded properties, then it can be more succinct than using `get`s\n * for each one.\n *\n * This function returns a proxy to an entity, instead of a real entity, and as such its return\n * value should only be used as part of a destructure and never directly assigned to a variable.\n *\n * This is also why the function is not recursive, as returning nested proxies could result in\n * them inadvertently being stored and passed to code that expects a real entity.\n */\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  promise: Promise<L>,\n): Promise<WithLoaded<T, H, L>>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loaded: L,\n): WithLoaded<T, H, L>;\nexport function withLoaded<T extends Entity, H extends LoadHint<T>, L extends Loaded<T, H>>(\n  loadedOrPromise: MaybePromise<L> | L,\n): MaybePromise<WithLoaded<T, H, L>> {\n  return maybePromiseThen(\n    loadedOrPromise,\n    (loaded) =>\n      new Proxy(loaded, {\n        get: (target, prop) => {\n          const value: any = (target as any)[prop];\n          if (\n            isRelation(value) ||\n            isProperty(value) ||\n            isReactiveField(value) ||\n            isReactiveGetter(value) ||\n            isAsyncReactiveField(value)\n          ) {\n            return isLoadedReference(value) ||\n              isLoadedCollection(value) ||\n              isLoadedProperty(value) ||\n              isReactiveField(value) ||\n              isLoadedAsyncReactiveField(value) ||\n              isReactiveGetter(value)\n              ? value.get\n              : fail(`${target}.${String(prop)} is not loaded`);\n          } else if (value instanceof StubbedRelation) {\n            return value.get;\n          } else {\n            return value;\n          }\n        },\n      }) as WithLoaded<T, H, L>,\n  );\n}\n\nexport function ensureWithLoaded<T extends Entity, const H extends LoadHint<T>>(\n  entity: T,\n  hint: H,\n): WithLoaded<T, H, Loaded<T, H>> {\n  assertLoaded<T, H>(entity, hint);\n  return withLoaded(entity);\n}\n\n/**\n * Allow stubbing of relations with dummy values.\n *\n * In very advanced use cases (ideally only useful in tests, similar to mocking), it can be helpful\n * to have a relation returned a hard-coded value that doesn't go through the normal o2m/m2m\n * .load/.isLoaded/.get code paths.\n *\n * We'd originally done some of this by poking relation internal implementation details, but\n * using private fields like `#loaded` breaks that, and it was brittle anyway.\n *\n * So StubbedRelation provides a semi-blessed way of doing this, i.e. with code like:\n *\n * ```\n * // Force `author.books` to always be `[]` and never load.\n * Object.defineProperty(author, \"books\", {\n *   get: () => new StubbedRelation([]),\n *  });\n * ```\n */\nexport class StubbedRelation {\n  constructor(private value: any) {}\n\n  get get() {\n    return this.value;\n  }\n\n  get isLoaded() {\n    return true;\n  }\n\n  load() {\n    return this.get;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAuEA,SAAgB,WACd,iBACmC;CACnC,OAAO,iBACL,kBACC,WACC,IAAI,MAAM,QAAQ,EAChB,MAAM,QAAQ,SAAS;EACrB,MAAM,QAAc,OAAe;EACnC,IACE,WAAW,KAAK,KAChB,WAAW,KAAK,KAChB,gBAAgB,KAAK,KACrB,iBAAiB,KAAK,KACtB,qBAAqB,KAAK,GAE1B,OAAO,kBAAkB,KAAK,KAC5B,mBAAmB,KAAK,KACxB,iBAAiB,KAAK,KACtB,gBAAgB,KAAK,KACrB,2BAA2B,KAAK,KAChC,iBAAiB,KAAK,IACpB,MAAM,MACN,KAAK,GAAG,OAAO,GAAG,OAAO,IAAI,EAAE,eAAe;OAC7C,IAAI,iBAAiB,iBAC1B,OAAO,MAAM;OAEb,OAAO;CAEX,EACF,CAAC,CACL;AACF;AAEA,SAAgB,iBACd,QACA,MACgC;CAChC,aAAmB,QAAQ,IAAI;CAC/B,OAAO,WAAW,MAAM;AAC1B;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,kBAAb,MAA6B;CACP;CAApB,YAAY,OAAoB;EAAZ,KAAA,QAAA;CAAa;CAEjC,IAAI,MAAM;EACR,OAAO,KAAK;CACd;CAEA,IAAI,WAAW;EACb,OAAO;CACT;CAEA,OAAO;EACL,OAAO,KAAK;CACd;AACF"}