@sequenceholdings/orm 2.8.3 → 2.8.5

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,14 @@ 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. A read-only
+         * table (no write policy) may then declare a composite key: several
+         * `.primaryKey()` columns that are exactly this source's primary key.
+         */
+        existsIn?: readonly string[];
     };
     links?: Record<string, SeqLink>;
     /** Reads use `read`; writes are evaluated against the resolved row. */
@@ -338,6 +346,8 @@ interface ResolvedViewConfig {
         orderBy?: string;
     }>;
     readonly deletedBy: readonly string[];
+    /** `rows.existsIn`: the etl source whose rows are the table's rows. */
+    readonly existsIn?: readonly string[];
     readonly policies: Omit<ResolvedTablePoliciesInput, 'read'>;
 }
 interface ResolvedSourcePlan {
@@ -547,7 +557,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,14 @@ 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. A read-only
+         * table (no write policy) may then declare a composite key: several
+         * `.primaryKey()` columns that are exactly this source's primary key.
+         */
+        existsIn?: readonly string[];
     };
     links?: Record<string, SeqLink>;
     /** Reads use `read`; writes are evaluated against the resolved row. */
@@ -338,6 +346,8 @@ interface ResolvedViewConfig {
         orderBy?: string;
     }>;
     readonly deletedBy: readonly string[];
+    /** `rows.existsIn`: the etl source whose rows are the table's rows. */
+    readonly existsIn?: readonly string[];
     readonly policies: Omit<ResolvedTablePoliciesInput, 'read'>;
 }
 interface ResolvedSourcePlan {
@@ -547,7 +557,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

@@ -1123,6 +1123,48 @@ var policyExpressionSchema = z.union([
     variants: z.array(policyVariantSchema).max(10).default([])
   })
 ]);
+
+// src/canonical/resolved-rows.ts
+function logicalKey(table) {
+  return (table.primaryKey ?? []).map((columnName) => table.columns.find((c) => c.columnName === columnName)?.name ?? columnName);
+}
+function sameKey(key, expected) {
+  return key.length === expected.length && key.every((name2) => expected.includes(name2));
+}
+function validateRowIdentity(input) {
+  validateExistsIn(input);
+  if (input.keys.length > 1) validateCompositeKey(input);
+}
+function validateExistsIn({ resolved, sourceByName, fail }) {
+  const name2 = resolved.existsIn?.[0];
+  if (name2 === void 0) return;
+  if (sourceByName.get(name2)?.kind !== "etl") fail(`existsIn '${name2}' must be an etl source`);
+  if (resolved.policies.insert !== void 0 || resolved.policies.write !== void 0) {
+    fail("existsIn allows only an update policy: rows come from the etl source");
+  }
+}
+function validateCompositeKey({ resolved, keys, tableByName, fail }) {
+  const keyList = `(${keys.join(", ")})`;
+  if (resolved.existsIn === void 0) {
+    fail(`requires exactly one primary-key column: composite key ${keyList} requires existsIn`);
+    return;
+  }
+  const writes = ["insert", "update", "write"].filter((kind) => resolved.policies[kind] !== void 0);
+  if (writes.length > 0) fail(`composite key ${keyList} requires a read-only table: remove the ${writes.join("/")} policy`);
+  if (resolved.materialized) fail(`composite key ${keyList} cannot be materialized`);
+  for (const source of resolved.sources) {
+    if (source.kind === "prefetch") {
+      fail(`composite key ${keyList} cannot have prefetch source '${source.name}'`);
+      continue;
+    }
+    const table = tableByName.get(source.table);
+    if (table && !sameKey(logicalKey(table), keys)) {
+      fail(`composite key ${keyList} requires ${source.kind} source '${source.name}' to be keyed by it; table '${source.table}' is keyed by (${logicalKey(table).join(", ")})`);
+    }
+  }
+}
+
+// src/canonical/resolved.ts
 function parseDurationMs(input) {
   if (typeof input === "number") return Number.isInteger(input) && input > 0 ? input : void 0;
   const match = /^(\d+(?:\.\d+)?)(ms|s|m)$/.exec(input);
@@ -1199,6 +1241,13 @@ var canonicalResolvedSchema = z.object({
   resolve: z.array(canonicalResolveRuleSchema).max(500),
   /** Sources whose tombstone hides the resolved row (v1: the manual source only). */
   deletedBy: z.array(identifier).max(1).default([]),
+  /**
+   * `rows.existsIn`: the one etl source whose rows are the table's rows (read
+   * directly as the row source). Only an update policy may write. It is also
+   * what admits a composite primary key: a read-only table keyed exactly like
+   * that source.
+   */
+  existsIn: z.array(identifier).length(1).optional(),
   /**
    * Materialized: the view reads an indexed internal table (`table`) that the
    * data plane keeps in step with `compute`, the internal view holding the
@@ -1217,8 +1266,8 @@ function validateResolvedView({ view, tables, views = [] }) {
   if (!resolved) return [];
   const errors = [];
   const fail = (message) => errors.push(`resolved table '${view.view}': ${message}`);
-  const pkColumn = view.primaryKey?.length === 1 ? view.columns.find((c) => c.columnName === view.primaryKey?.[0]) : void 0;
-  if (!pkColumn) {
+  const keyColumns = (view.primaryKey ?? []).map((columnName) => view.columns.find((c) => c.columnName === columnName)).filter((column) => column !== void 0);
+  if (keyColumns.length === 0 || keyColumns.length !== view.primaryKey?.length) {
     fail("requires exactly one primary-key column");
     return errors;
   }
@@ -1226,7 +1275,7 @@ function validateResolvedView({ view, tables, views = [] }) {
   const scope = {
     view,
     resolved,
-    pkColumn,
+    keys: new Map(keyColumns.map((column) => [column.name, column])),
     dataColumns: new Map(view.columns.filter((c) => !systemNames.has(c.name) && c.cell === void 0).map((c) => [c.name, c])),
     sourceByName: /* @__PURE__ */ new Map(),
     fail
@@ -1240,6 +1289,7 @@ function validateResolvedView({ view, tables, views = [] }) {
     if (!table) fail(`source '${source.name}' references unknown table '${source.table}'`);
     else validateSource({ scope, source, table });
   }
+  validateRowIdentity({ resolved, keys: [...scope.keys.keys()], sourceByName: scope.sourceByName, tableByName, fail });
   validateRules(scope);
   validateViewCells(scope);
   if (resolved.materialized) validateMaterialized({ scope, tableByName, views });
@@ -1269,7 +1319,7 @@ function validateSource({ scope, source, table }) {
   validatePrefetchFields({ scope, source });
 }
 function validatePrefetchFields({ scope, source }) {
-  const { fail, pkColumn } = scope;
+  const { fail, keys } = scope;
   if (source.kind !== "prefetch") {
     if (source.key || source.fetch || source.function || source.prefetchDefaults || source.writeback) {
       fail(`only prefetch sources may declare key/fetch/function/prefetchDefaults/writeback ('${source.name}')`);
@@ -1278,7 +1328,7 @@ function validatePrefetchFields({ scope, source }) {
   }
   if (!source.key || !source.fetch || !source.function || !source.prefetchDefaults) {
     fail(`prefetch source '${source.name}' requires key, fetch, function and prefetchDefaults`);
-  } else if (source.key !== pkColumn.name && !source.columns.includes(source.key)) {
+  } else if (!keys.has(source.key) && !source.columns.includes(source.key)) {
     fail(`prefetch source '${source.name}' key '${source.key}' must be the primary key or one of its columns`);
   }
   for (const column of source.writeback?.columns ?? []) {
@@ -1286,19 +1336,19 @@ function validatePrefetchFields({ scope, source }) {
   }
 }
 function validateSourceColumns({ scope, source, byName }) {
-  const { fail, pkColumn, dataColumns } = scope;
-  for (const column of [pkColumn.name, ...source.columns]) {
-    const own = column === pkColumn.name ? pkColumn : dataColumns.get(column);
+  const { fail, keys, dataColumns } = scope;
+  for (const column of [...keys.keys(), ...source.columns]) {
+    const own = keys.get(column) ?? dataColumns.get(column);
     const theirs = byName.get(column);
     if (!own) fail(`source '${source.name}' supplies unknown column '${column}'`);
     else if (!theirs) fail(`source '${source.name}' table '${source.table}' has no column '${column}'`);
     else if (JSON.stringify(theirs.type) !== JSON.stringify(own.type)) fail(`column '${column}' has a different type on source '${source.name}'`);
   }
 }
-function validateRules({ resolved, pkColumn, dataColumns, sourceByName, fail }) {
+function validateRules({ resolved, keys, dataColumns, sourceByName, fail }) {
   const ruled = /* @__PURE__ */ new Set();
   for (const rule of resolved.resolve) {
-    if (!dataColumns.has(rule.column) || rule.column === pkColumn.name) {
+    if (!dataColumns.has(rule.column) || keys.has(rule.column)) {
       fail(`resolve rule targets unknown column '${rule.column}'`);
       continue;
     }
@@ -1315,7 +1365,7 @@ function validateRules({ resolved, pkColumn, dataColumns, sourceByName, fail })
     }
   }
   for (const column of dataColumns.keys()) {
-    if (column !== pkColumn.name && !ruled.has(column)) fail(`column '${column}' has no resolve rule`);
+    if (!keys.has(column) && !ruled.has(column)) fail(`column '${column}' has no resolve rule`);
   }
 }
 var VIEW_CELL_TYPES = {
@@ -1324,10 +1374,10 @@ var VIEW_CELL_TYPES = {
   by: "text",
   conflicts: "jsonb"
 };
-function validateViewCells({ view, dataColumns, pkColumn, fail }) {
+function validateViewCells({ view, dataColumns, keys, fail }) {
   const expected = /* @__PURE__ */ new Map();
   for (const column of dataColumns.values()) {
-    if (column.name === pkColumn.name) continue;
+    if (keys.has(column.name)) continue;
     for (const part of RESOLVED_VIEW_CELL_PARTS) {
       expected.set(cellColumnName(column.name, part), { part, columnName: cellColumnName(column.columnName, part) });
     }
@@ -1695,7 +1745,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(),
@@ -2200,8 +2250,9 @@ function planSource(input) {
 }
 var tombstoned = () => t.boolean(RESOLVED_SOURCE_SYSTEM_COLUMNS.tombstoned.columnName).notNull().default(false);
 function internalTable(input, supplied, system, options = {}) {
-  const { viewName, sourceName, columns, pk, pkBuilder } = input;
-  const tableColumns = { [pk]: cloneColumn({ builder: pkBuilder, property: pk, notNull: true, primaryKey: true }) };
+  const { viewName, sourceName, columns, keys } = input;
+  const tableColumns = {};
+  for (const key of keys) tableColumns[key] = cloneColumn({ builder: columns[key], property: key, notNull: true, primaryKey: true });
   for (const property of supplied) {
     tableColumns[property] = cloneColumn({ builder: columns[property], property, notNull: false, primaryKey: false });
   }
@@ -2218,12 +2269,14 @@ function assertColumns(input, list, what) {
   for (const column of list) if (!input.dataColumns.includes(column)) input.fail(`${what} names unknown column "${column}"`);
 }
 function planEtl(input, source) {
-  const { sourceName, pk, dataColumns, fail } = input;
+  const { sourceName, keys, dataColumns, fail } = input;
   const table = typeof source.table === "function" ? source.table() : source.table;
   if (!isSeqTable(table) || table.source === void 0) fail(`etl source "${sourceName}" must reference a defineSyncedTable`);
   const synced = table;
   if (synced.config.primaryKey?.length === 0) fail(`etl source "${sourceName}" cannot use an unkeyed synced table for resolved row identity`);
-  if (!(pk in synced.columns)) fail(`etl source "${sourceName}" table "${synced.tableName}" has no "${pk}" column`);
+  for (const key of keys) {
+    if (!(key in synced.columns)) fail(`etl source "${sourceName}" table "${synced.tableName}" has no "${key}" column`);
+  }
   const supplied = source.columns ? [...source.columns] : dataColumns.filter((column) => column in synced.columns);
   assertColumns(input, supplied, `etl source "${sourceName}"`);
   if (source.updatedAt !== void 0 && !(source.updatedAt in synced.columns)) {
@@ -2232,9 +2285,9 @@ function planEtl(input, source) {
   return { name: sourceName, kind: "etl", table: synced, columns: supplied, ...source.updatedAt ? { updatedAt: source.updatedAt } : {} };
 }
 function planPrefetch(input, source) {
-  const { sourceName, pk, fail } = input;
+  const { sourceName, keys, fail } = input;
   assertColumns(input, source.columns, `prefetch source "${sourceName}"`);
-  if (source.key !== pk && !source.columns.includes(source.key)) {
+  if (!keys.includes(source.key) && !source.columns.includes(source.key)) {
     fail(`prefetch source "${sourceName}" key "${source.key}" must be the primary key or one of its columns`);
   }
   for (const column of source.writeback?.columns ?? []) {
@@ -2287,7 +2340,7 @@ var PG_TYPE = {
 var ident = (value) => `"${value.replace(/"/g, '""')}"`;
 var literal = (value) => `'${value.replace(/'/g, "''")}'`;
 var physical = ({ source, property }) => source.table.columns[property].columnNameFor(property);
-function candidateSql({ source, column, pk, pgType }) {
+function candidateSql({ source, column, key, pgType }) {
   const a = ident(`s_${source.name}`);
   const name2 = physical({ source, property: column });
   const value = `CAST(${a}.${ident(name2)} AS ${pgType})`;
@@ -2295,7 +2348,7 @@ function candidateSql({ source, column, pk, pgType }) {
     return {
       source: source.name,
       value,
-      has: `(${a}.${ident(physical({ source, property: pk }))} IS NOT NULL)`,
+      has: `(${a}.${ident(physical({ source, property: key }))} IS NOT NULL)`,
       at: source.updatedAt ? `CAST(${a}.${ident(physical({ source, property: source.updatedAt }))} AS timestamptz)` : "CAST(NULL AS timestamptz)",
       by: "CAST(NULL AS text)"
     };
@@ -2359,6 +2412,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})`);
@@ -2377,36 +2436,44 @@ function customCell({ candidates, orderBy, index }) {
 }
 function buildResolvedQuery({ context, plan }) {
   const { qb, relation } = context;
-  const pkColumn = plan.columns[plan.pk].columnNameFor(plan.pk);
+  const keyColumns = plan.keys.map((key) => plan.columns[key].columnNameFor(key));
   const alias = (source) => ident(`s_${source}`);
   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 keyRefs = plan.keys.map((key, index) => keySource ? `${alias(keySource.name)}.${ident(physical({ source: keySource, property: key }))}` : `"k".${ident(keyColumns[index])}`);
   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 selectedKey = plan.keys.map((key, index) => {
+      const sourceKey = ident(physical({ source, property: key }));
+      return sourceKey === ident(keyColumns[index]) ? sourceKey : `${sourceKey} AS ${ident(keyColumns[index])}`;
+    });
+    return sql`SELECT ${sql.raw(selectedKey.join(", "))} FROM ${relation(source.table)}${where}`;
+  });
+  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) => {
+    const on = plan.keys.map((key, index) => `${alias(source.name)}.${ident(physical({ source, property: key }))} = ${keyRefs[index]}`);
+    return sql` LEFT JOIN ${relation(source.table)} AS ${sql.raw(alias(source.name))} ON ${sql.raw(on.join(" AND "))}`;
   });
-  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 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 }));
+    const candidates = rule.candidates.map((name2) => candidateSql({ source: sourceByName.get(name2), column: rule.column, key: plan.keys[0], pgType }));
+    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 selected = {
-    [plan.pk]: sql.raw(`"k".${ident(pkColumn)}`).as(pkColumn)
-  };
+  const from = sql.join([base2, ...joins, ...laterals], sql.raw(""));
+  const selected = {};
   for (const [property, builder] of Object.entries(plan.columns)) {
-    if (property === plan.pk) continue;
-    const cell = cells.get(property);
     const columnName = builder.columnNameFor(property);
+    const keyIndex = plan.keys.indexOf(property);
+    if (keyIndex !== -1) {
+      selected[property] = sql.raw(keyRefs[keyIndex]).as(columnName);
+      continue;
+    }
+    const cell = cells.get(property);
     selected[property] = sql.raw(cell.value).as(columnName);
     for (const [part, expression] of Object.entries(cell.parts)) {
       selected[cellColumnName(property, part)] = sql.raw(expression).as(cellColumnName(columnName, part));
@@ -2420,6 +2487,44 @@ function buildResolvedQuery({ context, plan }) {
   const query = qb.select(selected).from(from);
   return hidden.length > 0 ? query.where(sql.raw(hidden.join(" AND "))) : query;
 }
+
+// src/authoring/resolved-rows.ts
+function planKeys({ columns, config, fail }) {
+  const keys = Object.entries(columns).filter(([, builder]) => builder.isPrimaryKey).map(([property]) => property);
+  if (keys.length === 0) fail("declare exactly one .primaryKey() column");
+  if (keys.length === 1) return keys;
+  const key = `(${keys.join(", ")})`;
+  if (config.rows?.existsIn === void 0) fail(`declare exactly one .primaryKey() column: composite key ${key} requires rows.existsIn`);
+  const writes = ["insert", "update", "write"].filter((kind) => config.policies[kind] !== void 0);
+  if (writes.length > 0) fail(`composite key ${key} requires a read-only table: remove the ${writes.join("/")} policy`);
+  if (config.materialize) fail(`composite key ${key} cannot be materialized`);
+  const prefetch = Object.entries(config.sources).find(([, source]) => source.kind === "prefetch");
+  if (prefetch) fail(`composite key ${key} cannot have prefetch source "${prefetch[0]}"`);
+  return keys;
+}
+function assertCompositeSourceKeys({ keys, plans, fail }) {
+  if (keys.length === 1) return;
+  for (const plan of plans) {
+    if (plan.kind !== "etl") continue;
+    const sourceKey = declaredPrimaryKeyProperties(plan.table);
+    if (sourceKey.length !== keys.length || !keys.every((key) => sourceKey.includes(key))) {
+      fail(`composite key (${keys.join(", ")}) requires etl source "${plan.name}" to be keyed by it; table "${plan.table.tableName}" is keyed by (${sourceKey.join(", ")})`);
+    }
+  }
+}
+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") return 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 }) {
+  if (!existsIn) return /* @__PURE__ */ new Set();
+  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 managedFn(id) {
   return { kind: "managed", id };
 }
@@ -2458,26 +2563,28 @@ function defineResolvedTable(name2, columns, config) {
       fail(`column "${property}" is too long for a resolved table (max ${MAX_TRACKED_COLUMN_NAME} characters, room for cell parts)`);
     }
   }
-  const pkEntries = Object.entries(columns).filter(([, builder]) => builder.isPrimaryKey);
-  if (pkEntries.length !== 1) fail("declare exactly one .primaryKey() column");
-  const [pk, pkBuilder] = pkEntries[0];
-  const dataColumns = Object.keys(columns).filter((property) => property !== pk);
+  const keys = planKeys({ columns, config, fail });
+  const dataColumns = Object.keys(columns).filter((property) => !keys.includes(property));
   if (dataColumns.length === 0) fail("declare at least one non-key column");
   const sourceEntries = Object.entries(config.sources);
   if (sourceEntries.filter(([, source]) => source.kind === "manual").length !== 1) fail("declare exactly one manualSource()");
   const plans = sourceEntries.map(
-    ([sourceName, input]) => planSource({ viewName: name2, sourceName, input, columns, pk, pkBuilder, dataColumns, fail })
+    ([sourceName, input]) => planSource({ viewName: name2, sourceName, input, columns, keys, dataColumns, fail })
   );
   const rules = planRules({ config, plans, dataColumns, fail });
   const deletedBy = [...config.rows?.deletedBy ?? []];
   for (const source of deletedBy) {
     if (plans.find((plan) => plan.name === source)?.kind !== "manual") fail(`rows.deletedBy "${source}" must be the manual source`);
   }
+  assertCompositeSourceKeys({ keys, plans, fail });
+  const existsIn = planExistsIn({ config, plans, fail });
+  const notNullColumns = inheritedNotNullColumns({ existsIn, rules });
   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 });
-    if (property === pk) continue;
+    const isKey = keys.includes(property);
+    viewColumns[property] = cloneColumn({ builder, property, notNull: isKey || notNullColumns.has(property), primaryKey: isKey });
+    if (isKey) continue;
     const columnName = builder.columnNameFor(property);
     for (const part of RESOLVED_VIEW_CELL_PARTS) {
       viewColumns[cellColumnName(property, part)] = partType[part](cellColumnName(columnName, part)).cellPart(property, part);
@@ -2490,9 +2597,10 @@ function defineResolvedTable(name2, columns, config) {
     sources: plans,
     rules,
     deletedBy,
+    ...existsIn ? { existsIn: [existsIn.name] } : {},
     policies: writePolicies
   };
-  const queryPlan = { columns, pk, plans, rules, deletedBy };
+  const queryPlan = { columns, keys, plans, rules, deletedBy, ...existsIn ? { existsIn: existsIn.name } : {} };
   const typedColumns = viewColumns;
   const surface = {
     ...config.description !== void 0 ? { description: config.description } : {},
@@ -3055,6 +3163,7 @@ function buildCanonicalResolved(resolved) {
     })),
     resolve: resolved.rules.map((rule) => ({ ...rule, candidates: [...rule.candidates] })),
     deletedBy: [...resolved.deletedBy],
+    ...resolved.existsIn !== void 0 ? { existsIn: [...resolved.existsIn] } : {},
     ...resolved.materialized ? { materialized: { ...resolved.materialized } } : {},
     policies
   };