@sequenceholdings/orm 2.8.1 → 2.8.3

package/dist/cli.js

@@ -1,6 +1,7 @@
 import { readdir, readFile, mkdir, writeFile, stat, rm, realpath } from 'fs/promises';
 import { createRequire } from 'module';
 import { basename, resolve, join, dirname, sep, extname } from 'path';
+import { text } from 'stream/consumers';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { createJiti } from 'jiti';
 import { createHash } from 'crypto';
@@ -8,7 +9,7 @@ import { z } from 'zod';
 import { buildSchema, parse, validate, Kind, valueFromASTUntyped, visit, print } from 'graphql';
 import { PgParser } from '@supabase/pg-parser';
 import { sql } from 'drizzle-orm';
-import { pgSchema, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, check, foreignKey, uniqueIndex, index, primaryKey, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text, uuid } from 'drizzle-orm/pg-core';
+import { pgSchema, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, check, foreignKey, uniqueIndex, index, primaryKey, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text as text$1, uuid } from 'drizzle-orm/pg-core';
 import { generateDrizzleJson, upPgSnapshot, generateMigration } from 'drizzle-kit/api';
 import { load } from 'js-yaml';
 import { capabilityPinsSchema, customRolesBlockSchema, validateCapabilityPins } from '@sequenceholdings/custom-roles-manifest';
@@ -5461,8 +5462,8 @@ var SqlEmitter = class {
     }
     const result = node.op === "SETOP_UNION" ? this.union(node, scope) : this.projection(node, scope);
     const { columns } = result;
-    let text4 = `${ctes.length ? `WITH ${ctes.join(", ")} ` : ""}${result.text}`;
-    if (list(node.sortClause).length) text4 += ` ORDER BY ${list(node.sortClause).map((n) => {
+    let text5 = `${ctes.length ? `WITH ${ctes.join(", ")} ` : ""}${result.text}`;
+    if (list(node.sortClause).length) text5 += ` ORDER BY ${list(node.sortClause).map((n) => {
       const sort = obj(obj(n).SortBy);
       only(sort, ["node", "sortby_dir", "sortby_nulls", "location"]);
       const direction = sort.sortby_dir === "SORTBY_DESC" ? "DESC" : sort.sortby_dir === "SORTBY_ASC" || sort.sortby_dir === "SORTBY_DEFAULT" ? "ASC" : fail3("unsupported SQL sort");
@@ -5473,10 +5474,10 @@ var SqlEmitter = class {
       return `${projected.length === 1 ? quoteIdentifier(projected[0].name) : this.expr(value, scope).text} ${direction}${nulls}`;
     }).join(", ")}`;
     for (const [key, keyword] of [["limitCount", "LIMIT"], ["limitOffset", "OFFSET"]]) {
-      if (node[key]) text4 += ` ${keyword} ${this.expr(obj(node[key]), scope).text}`;
+      if (node[key]) text5 += ` ${keyword} ${this.expr(obj(node[key]), scope).text}`;
     }
     this.depth--;
-    return { text: text4, columns: resolveUnknown ? columns.map((c) => c.type === "unknown" ? { ...c, type: "text" } : c) : columns };
+    return { text: text5, columns: resolveUnknown ? columns.map((c) => c.type === "unknown" ? { ...c, type: "text" } : c) : columns };
   }
   union(node, scope) {
     for (const key of ["targetList", "fromClause", "whereClause", "groupClause", "havingClause"]) {
@@ -5517,11 +5518,11 @@ var SqlEmitter = class {
       }
     }
     if (!targets.length || targets.length > 256) fail3("invalid SQL projection");
-    let text4 = `SELECT ${targets.join(", ")}${from ? ` FROM ${from}` : ""}`;
-    if (node.whereClause) text4 += ` WHERE ${this.expr(obj(node.whereClause), scope).text}`;
-    if (list(node.groupClause).length) text4 += ` GROUP BY ${list(node.groupClause).map((n) => this.expr(obj(n), scope).text).join(", ")}`;
-    if (node.havingClause) text4 += ` HAVING ${this.expr(obj(node.havingClause), scope).text}`;
-    return { text: text4, columns };
+    let text5 = `SELECT ${targets.join(", ")}${from ? ` FROM ${from}` : ""}`;
+    if (node.whereClause) text5 += ` WHERE ${this.expr(obj(node.whereClause), scope).text}`;
+    if (list(node.groupClause).length) text5 += ` GROUP BY ${list(node.groupClause).map((n) => this.expr(obj(n), scope).text).join(", ")}`;
+    if (node.havingClause) text5 += ` HAVING ${this.expr(obj(node.havingClause), scope).text}`;
+    return { text: text5, columns };
   }
   from(node, scope) {
     this.budget();
@@ -6004,7 +6005,7 @@ function generateSqlOperations({ artifact }) {
       lines.push(
         `export type ${prefix}Variables = SqlQueryVariables`,
         `export type ${prefix}Result = SqlQueryResult`,
-        `export const ${prefix}: OperationReference<${prefix}Variables, ${prefix}Result> = ${JSON.stringify({ namespace: artifact.namespace, hash: operation.opHash })}`,
+        `export const ${prefix}: OperationReference<${prefix}Variables, ${prefix}Result> = ${JSON.stringify({ namespace: artifact.namespace, name: operation.name, kind: operation.kind })}`,
         ""
       );
       continue;
@@ -6019,7 +6020,7 @@ function generateSqlOperations({ artifact }) {
 ${variables}
 }`,
       `export type ${prefix}Result = { columns: Array<{ name: string; type: string; nullable: boolean }>; rows: Array<[${row}]>; truncated: boolean }`,
-      `export const ${prefix}: OperationReference<${prefix}Variables, ${prefix}Result> = ${JSON.stringify({ namespace: artifact.namespace, hash: operation.opHash })}`,
+      `export const ${prefix}: OperationReference<${prefix}Variables, ${prefix}Result> = ${JSON.stringify({ namespace: artifact.namespace, name: operation.name, kind: operation.kind })}`,
       ""
     );
   }
@@ -6080,7 +6081,7 @@ function isSeqView(value) {
 }
 var QUERY_COLUMN_FACTORIES = {
   uuid: (name2) => uuid(name2),
-  text: (name2) => text(name2),
+  text: (name2) => text$1(name2),
   integer: (name2) => integer(name2),
   bigint: (name2) => bigint(name2, { mode: "bigint" }),
   numeric: (name2) => numeric(name2),
@@ -6809,29 +6810,23 @@ var CodegenGqlError = class extends Error {
     this.name = "CodegenGqlError";
   }
 };
-var MANIFEST_VERSION = 1;
-var OP_HASH_RE = /^sha256:[0-9a-f]{64}$/;
+var MANIFEST_VERSION = 2;
 var GRAPHQL_NAME_RE = /^[_A-Za-z][_0-9A-Za-z]*$/;
 var manifestRequiresSchema = z.object({
   capability: z.string().min(1).optional(),
   role: z.string().min(1).optional()
 }).nullable();
 var manifestOperationSchema = z.object({
-  hash: z.string().regex(OP_HASH_RE),
   kind: z.enum(["query", "mutation"]),
   requires: manifestRequiresSchema
 });
 var operationsManifestSchema = z.object({
-  manifestVersion: z.literal(MANIFEST_VERSION),
-  schemaHash: z.string().min(1),
-  opsHash: z.string().regex(OP_HASH_RE),
+  manifestVersion: z.union([z.literal(1), z.literal(MANIFEST_VERSION)]),
   operations: z.record(z.string().regex(GRAPHQL_NAME_RE), manifestOperationSchema)
 });
 function buildOperationsManifest({
-  schemaHash,
   operations
 }) {
-  if (schemaHash.length === 0) throw new CodegenGqlError("schemaHash must be a non-empty string.");
   const sorted = [...operations].sort((a, b) => a.name.localeCompare(b.name));
   const seen = /* @__PURE__ */ new Set();
   const entries = sorted.map((op) => {
@@ -6842,20 +6837,14 @@ function buildOperationsManifest({
       throw new CodegenGqlError(`Duplicate operation name "${op.name}" \u2014 operation names must be unique per namespace.`);
     }
     seen.add(op.name);
-    if (!OP_HASH_RE.test(op.hash)) {
-      throw new CodegenGqlError(`Operation "${op.name}" has malformed hash "${op.hash}" (expected sha256:<64 hex>).`);
-    }
-    return { name: op.name, hash: op.hash, kind: op.kind, requires: normalizeRequires(op.requires) };
+    return { name: op.name, kind: op.kind, requires: normalizeRequires(op.requires) };
   });
-  const opsHash = `sha256:${createHash("sha256").update(stableJson(entries)).digest("hex")}`;
   const operationsRecord = {};
   for (const entry of entries) {
-    operationsRecord[entry.name] = { hash: entry.hash, kind: entry.kind, requires: entry.requires };
+    operationsRecord[entry.name] = { kind: entry.kind, requires: entry.requires };
   }
   return {
     manifestVersion: MANIFEST_VERSION,
-    schemaHash,
-    opsHash,
     operations: operationsRecord
   };
 }
@@ -7130,8 +7119,8 @@ function renderEnum(name2, values) {
 ${values.map((value) => `  ${value}`).join("\n")}
 }`;
 }
-function descriptionLines(text4, indent) {
-  const escaped = text4.replace(/"""/g, '\\"""');
+function descriptionLines(text5, indent) {
+  const escaped = text5.replace(/"""/g, '\\"""');
   return [`${indent}"""`, ...escaped.split("\n").map((line) => `${indent}${line}`), `${indent}"""`];
 }
 var PATTERN_COMPARISON_TYPES = /* @__PURE__ */ new Set(["String", "Int", "bigint", "uuid"]);
@@ -8466,7 +8455,7 @@ function comparisonTypeIssue(left, right, columns) {
 }
 var FACTORIES = {
   uuid: (name2) => uuid(name2),
-  text: (name2) => text(name2),
+  text: (name2) => text$1(name2),
   integer: (name2) => integer(name2),
   // Mode 'bigint' keeps int8 lossless — mode 'number' silently rounds past
   // 2^53. The read executor serializes BigInt to string for JSON.
@@ -8850,7 +8839,7 @@ function refreshFunctionStatements({ namespace, previous, current }) {
 // src/engine/canonical2.ts
 var FACTORIES2 = {
   uuid: (name2) => uuid(name2),
-  text: (name2) => text(name2),
+  text: (name2) => text$1(name2),
   integer: (name2) => integer(name2),
   // Mode 'bigint' keeps int8 lossless — mode 'number' silently rounds past
   // 2^53. The read executor serializes BigInt to string for JSON.
@@ -10302,7 +10291,7 @@ async function readMigrationSql(dir, entry) {
     throw new OrmDefinitionError("missing migration file", path);
   });
 }
-var checksumOf = (text4) => createHash("sha256").update(text4).digest("hex");
+var checksumOf = (text5) => createHash("sha256").update(text5).digest("hex");
 var migrationName = (ordinal, contentHash) => `${pad(ordinal)}_${contentHash.slice(0, 12)}`;
 function renderMigrationSql({
   name: name2,
@@ -10671,10 +10660,10 @@ function createOrmMigrationExport({ schemaHash, payload }) {
   return { ...contents, checksum: checksum(contents) };
 }
 function renderOrmMigrationExport(exported) {
-  const text4 = `${JSON.stringify(exported, null, 2)}
+  const text5 = `${JSON.stringify(exported, null, 2)}
 `;
-  if (Buffer.byteLength(text4, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
-  return text4;
+  if (Buffer.byteLength(text5, "utf8") > ORM_MIGRATION_EXPORT_MAX_BYTES) throw new Error("ORM migration export exceeds the size limit");
+  return text5;
 }
 
 // src/compiler-gql/role-warnings.ts
@@ -10894,7 +10883,7 @@ function renderImportScript({
   const procedure = renderProcedure({ targetSql, sourceSql, mapped, keys, onConflict, batchSize });
   const call = `CALL pg_temp.seq_orm_import(${resume.join(", ")});`;
   const omittedLine = omitted.length > 0 ? `-- Omitted columns keep their database default or NULL: ${omitted.join(", ")}` : "-- Every column is mapped.";
-  const text4 = [
+  const text5 = [
     "-- Sequence ORM data import",
     `-- namespace: ${namespace}`,
     `-- target: ${schemaName}.${table.table}`,
@@ -10918,7 +10907,7 @@ function renderImportScript({
     call,
     ""
   ].join("\n");
-  return { probeSql, text: text4 };
+  return { probeSql, text: text5 };
 }
 function renderProbe({
   sourceSql,
@@ -11291,10 +11280,10 @@ async function readSpec(flags) {
     if (flags["--table"] || flags["--from"] || flags["--map"]) {
       return { error: "--spec replaces --table, --from, and --map" };
     }
-    const text4 = await readFile(resolve(flags["--spec"]), "utf8");
+    const text5 = await readFile(resolve(flags["--spec"]), "utf8");
     let parsed;
     try {
-      parsed = JSON.parse(text4);
+      parsed = JSON.parse(text5);
     } catch {
       return { error: `--spec ${flags["--spec"]} is not valid JSON` };
     }
@@ -11374,6 +11363,7 @@ var USAGE = `usage:
                                         --no-wait returns once the apply is queued
   seq-studio orm execute <operation> [dir] --variables-file <file> -e <env>
                                         execute one named persisted operation from this checkout's manifest as the signed-in caller
+                                        variables-file accepts - or /dev/stdin to read JSON from stdin until EOF
   seq-studio orm execute <namespace> <operation> -e <env> [--variables-file <file>] [--var <name>=<value>]...
                                         execute the deployed version's operation by name (no checkout; seq-studio only)
   seq-studio orm diff [dir]              write/verify the committed migration standalone (--check is the offline CI gate; --allow-destructive consents; --rebase records a v1 -> v2 conversion as a verified no-op)
@@ -11654,21 +11644,21 @@ async function generateCommand(rest) {
       schema_snapshot: workspace.tipSnapshot,
       ...migration ? { migration } : {}
     } });
-    const text4 = renderOrmMigrationExport(exported);
+    const text5 = renderOrmMigrationExport(exported);
     const path = join(dir, ORM_MIGRATION_EXPORT_FILE);
     if (check) {
       const committed = await readFile(path, "utf8").catch((error) => {
         if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
         throw error;
       });
-      if (committed !== text4) {
+      if (committed !== text5) {
         console.error(`${ORM_MIGRATION_EXPORT_FILE} is missing or stale; run seq-studio orm generate ${dir} --migration-export and commit it`);
         return 1;
       }
       console.log(`${ORM_MIGRATION_EXPORT_FILE} matches the current definitions, operations, and committed migration`);
       return 0;
     }
-    await writeFile(path, text4);
+    await writeFile(path, text5);
     console.log(`wrote ${ORM_MIGRATION_EXPORT_FILE} (${exported.checksum.slice(0, 12)})`);
   }
   await writeGenerateOutputs(dir, compiled.project);
@@ -11685,11 +11675,10 @@ async function writeGenerateOutputs(dir, project) {
 `);
   const operations = Object.entries(manifest.operations).map(([name2, op]) => ({
     name: name2,
-    hash: op.opHash,
     kind: op.kind,
     requires: op.requires
   }));
-  const manifestFile = buildOperationsManifest({ schemaHash: manifest.schemaHash, operations });
+  const manifestFile = buildOperationsManifest({ operations });
   await writeFile(join(dir, OPERATIONS_MANIFEST_FILE), `${JSON.stringify(manifestFile, null, 2)}
 `);
   await writeFile(join(dir, TYPE_POLICIES_FILE), generateTypePolicies(loaded.canonical));
@@ -11760,7 +11749,8 @@ function parseExecuteArgs(rest) {
 async function readExecuteVariables(variablesFile) {
   let parsed;
   try {
-    parsed = JSON.parse(await readFile(resolve(variablesFile), "utf8"));
+    const contents = variablesFile === "-" || variablesFile === "/dev/stdin" ? await text(process.stdin) : await readFile(resolve(variablesFile), "utf8");
+    parsed = JSON.parse(contents);
   } catch (error) {
     throw new OrmDefinitionError(
       `could not read JSON variables from ${variablesFile}: ${error instanceof Error ? error.message : String(error)}`
@@ -11802,13 +11792,12 @@ async function executeV2Command(rest) {
   const namespace = loaded.canonical.namespace;
   let response;
   try {
-    response = await apiRequestStrict("POST", `${DATA_ENDPOINT_PREFIX}/${namespace}`, { op: selected.hash, variables });
+    response = await apiRequestStrict("POST", `${DATA_ENDPOINT_PREFIX}/${namespace}`, { op: `${selected.kind}:${operation}`, expectedKind: selected.kind, variables });
   } catch (error) {
     if (!(error instanceof AtlasRequestError) || error.status !== 404) throw error;
     const diagnosis = await diagnoseUnknownOperation({
       namespace,
       operation,
-      localHash: selected.hash,
       retry: `seq-studio orm execute ${namespace} ${operation}${env ? ` -e ${env}` : ""} --variables-file ${variablesFile}`
     }).catch(() => null);
     throw diagnosis ? new OrmDefinitionError(diagnosis) : error;
@@ -11816,7 +11805,7 @@ async function executeV2Command(rest) {
   console.log(JSON.stringify(response, null, 2));
   return 0;
 }
-async function diagnoseUnknownOperation({ namespace, operation, localHash, retry }) {
+async function diagnoseUnknownOperation({ namespace, operation, retry }) {
   const encoded = encodeURIComponent(namespace);
   const listing = await apiRequest(
     "GET",
@@ -11839,15 +11828,10 @@ async function diagnoseUnknownOperation({ namespace, operation, localHash, retry
   if (!deployed) {
     return `operation ${operation} is not in ${namespace}'s deployed version ${listing.schema_version_id}. Apply this checkout to deploy it (seq-studio orm apply), or list the deployed operations: seq-studio orm describe ${namespace} --operations`;
   }
-  if (deployed.op_hash === localHash) return null;
   return [
-    `operation ${operation}: this checkout's ${OPERATIONS_MANIFEST_FILE} does not match ${namespace}'s deployed version.`,
-    `  local hash:       ${localHash}`,
-    `  deployed hash:    ${deployed.op_hash}`,
-    `  deployed version: ${listing.schema_version_id}`,
-    "Run the deployed operation by name (no checkout needed):",
-    `  ${retry}`,
-    "Or bring the checkout up to date (git pull, then seq-studio orm generate) and retry."
+    `operation ${operation} exists in ${namespace}'s deployed version ${listing.schema_version_id}, but its guarded name was refused.`,
+    "Update Atlas to a runtime that supports guarded operation names, or retry if the operation set changed during lookup.",
+    `  ${retry}`
   ].join("\n");
 }
 async function validateV2Command(dir) {