@sequenceholdings/orm 2.8.2 → 2.8.4

package/dist/authoring.d.cts

@@ -286,7 +286,7 @@ declare const nonNullFirst: (candidates: readonly string[]) => Comparator;
  * wins; `ord` is always appended as the final tie-break.
  *
  * ```ts
- * custom(['edits', 'abrigo'], "CASE WHEN source = 'abrigo' AND value IS NOT NULL THEN 0 ELSE 1 END")
+ * custom(['edits', 'vendor'], "CASE WHEN source = 'vendor' AND value IS NOT NULL THEN 0 ELSE 1 END")
  * ```
  */
 declare const custom: (candidates: readonly string[], orderBy: string) => Comparator;
@@ -305,6 +305,12 @@ interface ResolvedTableConfig {
     default?: Comparator;
     rows?: {
         deletedBy?: readonly string[];
+        /**
+         * A row exists only while this etl source has its key; edits and other
+         * sources only change values. A column resolved from this source alone
+         * keeps the synced column's NOT NULL. Exactly one etl source.
+         */
+        existsIn?: readonly string[];
     };
     links?: Record<string, SeqLink>;
     /** Reads use `read`; writes are evaluated against the resolved row. */
@@ -547,7 +553,7 @@ interface ForeignKeyInput {
 interface TableConfig {
     displayName?: string;
     description?: string;
-    /** Table-level migration rename hint (new in v2). */
+    /** Table-level migration rename hint. */
     renamedFrom?: string;
     /** Composite primary key: property names (or column names). Mutually exclusive with column-level `.primaryKey()`. */
     primaryKey?: readonly string[];

package/dist/authoring.d.ts

@@ -286,7 +286,7 @@ declare const nonNullFirst: (candidates: readonly string[]) => Comparator;
  * wins; `ord` is always appended as the final tie-break.
  *
  * ```ts
- * custom(['edits', 'abrigo'], "CASE WHEN source = 'abrigo' AND value IS NOT NULL THEN 0 ELSE 1 END")
+ * custom(['edits', 'vendor'], "CASE WHEN source = 'vendor' AND value IS NOT NULL THEN 0 ELSE 1 END")
  * ```
  */
 declare const custom: (candidates: readonly string[], orderBy: string) => Comparator;
@@ -305,6 +305,12 @@ interface ResolvedTableConfig {
     default?: Comparator;
     rows?: {
         deletedBy?: readonly string[];
+        /**
+         * A row exists only while this etl source has its key; edits and other
+         * sources only change values. A column resolved from this source alone
+         * keeps the synced column's NOT NULL. Exactly one etl source.
+         */
+        existsIn?: readonly string[];
     };
     links?: Record<string, SeqLink>;
     /** Reads use `read`; writes are evaluated against the resolved row. */
@@ -547,7 +553,7 @@ interface ForeignKeyInput {
 interface TableConfig {
     displayName?: string;
     description?: string;
-    /** Table-level migration rename hint (new in v2). */
+    /** Table-level migration rename hint. */
     renamedFrom?: string;
     /** Composite primary key: property names (or column names). Mutually exclusive with column-level `.primaryKey()`. */
     primaryKey?: readonly string[];

package/dist/authoring.js

@@ -1695,7 +1695,7 @@ var canonicalTableSchema = z.object({
   table: identifier2,
   displayName: z.string().trim().min(1).max(120).optional(),
   description: z.string().max(2e3).optional(),
-  /** Table-level rename hint (new in v2). */
+  /** Table-level rename hint. */
   renamedFrom: identifier2.optional(),
   /** Synced/reflected read-only tables (`source: schema.table`) — v1 semantics. */
   source: z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
@@ -2359,6 +2359,12 @@ function builtinCell({ comparator, candidates }) {
     }
   };
 }
+function existsInCell(candidate) {
+  return {
+    value: candidate.value,
+    parts: { source: literal(candidate.source), at: candidate.at, by: candidate.by, conflicts: "CAST(NULL AS jsonb)" }
+  };
+}
 function customCell({ candidates, orderBy, index }) {
   const w = ident(`w_${index}`);
   const rows = candidates.map((c, ord) => `(${literal(c.source)}, ${c.has}, ${c.value}, ${c.at}, ${c.by}, ${ord})`);
@@ -2382,26 +2388,29 @@ function buildResolvedQuery({ context, plan }) {
   const tombstoned2 = RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.columnName;
   const sourceByName = new Map(plan.plans.map((source) => [source.name, source]));
   const schema = getTableConfig(relation(plan.plans[0].table)).schema;
+  const keySource = plan.existsIn === void 0 ? void 0 : sourceByName.get(plan.existsIn);
+  const keyRef = keySource ? `${alias(keySource.name)}.${ident(physical({ source: keySource, property: plan.pk }))}` : `"k".${ident(pkColumn)}`;
   const keyBranches = plan.plans.map((source) => {
     const where = source.kind === "prefetch" ? sql.raw(` WHERE NOT ${ident(tombstoned2)}`) : sql.raw("");
     const sourcePk = ident(physical({ source, property: plan.pk }));
     const selectedPk = sourcePk === ident(pkColumn) ? sourcePk : `${sourcePk} AS ${ident(pkColumn)}`;
     return sql`SELECT ${sql.raw(selectedPk)} FROM ${relation(source.table)}${where}`;
   });
-  const joins = plan.plans.map(
-    (source) => sql` LEFT JOIN ${relation(source.table)} AS ${sql.raw(alias(source.name))} ON ${sql.raw(`${alias(source.name)}.${ident(physical({ source, property: plan.pk }))} = "k".${ident(pkColumn)}`)}`
+  const base2 = keySource ? sql`${relation(keySource.table)} AS ${sql.raw(alias(keySource.name))}` : sql`(${sql.join(keyBranches, sql.raw(" UNION "))}) AS "k"`;
+  const joins = plan.plans.filter((source) => source !== keySource).map(
+    (source) => sql` LEFT JOIN ${relation(source.table)} AS ${sql.raw(alias(source.name))} ON ${sql.raw(`${alias(source.name)}.${ident(physical({ source, property: plan.pk }))} = ${keyRef}`)}`
   );
   const cells = /* @__PURE__ */ new Map();
   plan.rules.forEach((rule, index) => {
     const canonical = plan.columns[rule.column].toCanonicalColumn(rule.column);
     const pgType = typeof canonical.type === "string" ? PG_TYPE[canonical.type] : `${schema === void 0 ? "" : `${ident(schema)}.`}${ident(canonical.type.enum)}`;
     const candidates = rule.candidates.map((name2) => candidateSql({ source: sourceByName.get(name2), column: rule.column, pk: plan.pk, pgType }));
-    cells.set(rule.column, rule.comparator === "custom" ? customCell({ candidates, orderBy: rule.orderBy, index }) : builtinCell({ comparator: rule.comparator, candidates }));
+    cells.set(rule.column, keySource && rule.candidates.length === 1 && rule.candidates[0] === keySource.name ? existsInCell(candidates[0]) : rule.comparator === "custom" ? customCell({ candidates, orderBy: rule.orderBy, index }) : builtinCell({ comparator: rule.comparator, candidates }));
   });
   const laterals = [...cells.values()].flatMap((cell) => cell.lateral ? [sql.raw(cell.lateral)] : []);
-  const from = sql.join([sql`(${sql.join(keyBranches, sql.raw(" UNION "))}) AS "k"`, ...joins, ...laterals], sql.raw(""));
+  const from = sql.join([base2, ...joins, ...laterals], sql.raw(""));
   const selected = {
-    [plan.pk]: sql.raw(`"k".${ident(pkColumn)}`).as(pkColumn)
+    [plan.pk]: sql.raw(keyRef).as(pkColumn)
   };
   for (const [property, builder] of Object.entries(plan.columns)) {
     if (property === plan.pk) continue;
@@ -2473,10 +2482,12 @@ function defineResolvedTable(name2, columns, config) {
   for (const source of deletedBy) {
     if (plans.find((plan) => plan.name === source)?.kind !== "manual") fail(`rows.deletedBy "${source}" must be the manual source`);
   }
+  const existsIn = planExistsIn({ config, plans, fail });
+  const notNullColumns = existsIn ? inheritedNotNullColumns({ existsIn, rules }) : /* @__PURE__ */ new Set();
   const partType = { source: t.text, at: t.timestamptz, by: t.text, conflicts: t.jsonb };
   const viewColumns = {};
   for (const [property, builder] of Object.entries(columns)) {
-    viewColumns[property] = cloneColumn({ builder, property, notNull: property === pk, primaryKey: property === pk });
+    viewColumns[property] = cloneColumn({ builder, property, notNull: property === pk || notNullColumns.has(property), primaryKey: property === pk });
     if (property === pk) continue;
     const columnName = builder.columnNameFor(property);
     for (const part of RESOLVED_VIEW_CELL_PARTS) {
@@ -2492,7 +2503,7 @@ function defineResolvedTable(name2, columns, config) {
     deletedBy,
     policies: writePolicies
   };
-  const queryPlan = { columns, pk, plans, rules, deletedBy };
+  const queryPlan = { columns, pk, plans, rules, deletedBy, ...existsIn ? { existsIn: existsIn.name } : {} };
   const typedColumns = viewColumns;
   const surface = {
     ...config.description !== void 0 ? { description: config.description } : {},
@@ -2534,6 +2545,18 @@ function defineResolvedTable(name2, columns, config) {
     }
   });
 }
+function planExistsIn({ config, plans, fail }) {
+  const names = config.rows?.existsIn;
+  if (names === void 0) return void 0;
+  if (names.length !== 1) fail("rows.existsIn names exactly one etl source");
+  const source = plans.find((plan) => plan.name === names[0]);
+  if (source?.kind !== "etl") fail(`rows.existsIn "${names[0]}" must be an etl source`);
+  if (config.policies.insert !== void 0 || config.policies.write !== void 0) fail("rows.existsIn allows only an update policy: rows come from the etl source");
+  return source;
+}
+function inheritedNotNullColumns({ existsIn, rules }) {
+  return new Set(rules.filter((rule) => rule.candidates.length === 1 && rule.candidates[0] === existsIn.name).map((rule) => rule.column).filter((column) => existsIn.table.columns[column]?.toCanonicalColumn(column).nullable === false));
+}
 function planRules({ config, plans, dataColumns, fail }) {
   const kindOrder = { manual: 0, prefetch: 1, etl: 2 };
   const fallback = config.default ?? priority([...plans].sort((a, b) => kindOrder[a.kind] - kindOrder[b.kind]).map((plan) => plan.name));