@sequenceholdings/orm 2.8.2 → 2.8.4

package/README.md

@@ -127,6 +127,11 @@ seq-studio orm execute GetOpenDeals . \
 `variables.json` must contain a JSON object. The platform validates variables,
 operation requirements, and row policies as the signed-in caller.
 
+For piped input, use `--variables-file -` (`/dev/stdin` is also supported).
+The CLI consumes UTF-8 stdin until EOF before parsing the JSON object and
+submitting the operation. This keeps large inputs in memory without a temporary
+variables file. Input failures do not submit the operation or retry a mutation.
+
 Execute posts the persistent operation name and expected query/mutation kind to
 Atlas's `/api/data/v2` endpoint. Version 2 `operations.manifest.json` files contain
 names, kinds, and gates without schema or operation hashes. Updated clients also

package/dist/authoring.cjs

@@ -1698,7 +1698,7 @@ var canonicalTableSchema = zod.z.object({
   table: identifier2,
   displayName: zod.z.string().trim().min(1).max(120).optional(),
   description: zod.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: zod.z.string().regex(QUALIFIED_TABLE_PATTERN).optional(),
@@ -2362,6 +2362,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})`);
@@ -2385,26 +2391,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 = pgCore.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" ? drizzleOrm.sql.raw(` WHERE NOT ${ident(tombstoned2)}`) : drizzleOrm.sql.raw("");
     const sourcePk = ident(physical({ source, property: plan.pk }));
     const selectedPk = sourcePk === ident(pkColumn) ? sourcePk : `${sourcePk} AS ${ident(pkColumn)}`;
     return drizzleOrm.sql`SELECT ${drizzleOrm.sql.raw(selectedPk)} FROM ${relation(source.table)}${where}`;
   });
-  const joins = plan.plans.map(
-    (source) => drizzleOrm.sql` LEFT JOIN ${relation(source.table)} AS ${drizzleOrm.sql.raw(alias(source.name))} ON ${drizzleOrm.sql.raw(`${alias(source.name)}.${ident(physical({ source, property: plan.pk }))} = "k".${ident(pkColumn)}`)}`
+  const base2 = keySource ? drizzleOrm.sql`${relation(keySource.table)} AS ${drizzleOrm.sql.raw(alias(keySource.name))}` : drizzleOrm.sql`(${drizzleOrm.sql.join(keyBranches, drizzleOrm.sql.raw(" UNION "))}) AS "k"`;
+  const joins = plan.plans.filter((source) => source !== keySource).map(
+    (source) => drizzleOrm.sql` LEFT JOIN ${relation(source.table)} AS ${drizzleOrm.sql.raw(alias(source.name))} ON ${drizzleOrm.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 ? [drizzleOrm.sql.raw(cell.lateral)] : []);
-  const from = drizzleOrm.sql.join([drizzleOrm.sql`(${drizzleOrm.sql.join(keyBranches, drizzleOrm.sql.raw(" UNION "))}) AS "k"`, ...joins, ...laterals], drizzleOrm.sql.raw(""));
+  const from = drizzleOrm.sql.join([base2, ...joins, ...laterals], drizzleOrm.sql.raw(""));
   const selected = {
-    [plan.pk]: drizzleOrm.sql.raw(`"k".${ident(pkColumn)}`).as(pkColumn)
+    [plan.pk]: drizzleOrm.sql.raw(keyRef).as(pkColumn)
   };
   for (const [property, builder] of Object.entries(plan.columns)) {
     if (property === plan.pk) continue;
@@ -2476,10 +2485,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) {
@@ -2495,7 +2506,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 } : {},
@@ -2537,6 +2548,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));