@sequenceholdings/orm 2.8.1 → 2.8.2

package/dist/canonical.d.ts

@@ -102,8 +102,8 @@ type CanonicalFetchShape = z.infer<typeof canonicalFetchShapeSchema>;
 declare const canonicalResolvedSourceSchema: z.ZodObject<{
     name: z.ZodString;
     kind: z.ZodEnum<{
-        prefetch: "prefetch";
         manual: "manual";
+        prefetch: "prefetch";
         etl: "etl";
     }>;
     table: z.ZodString;
@@ -160,8 +160,8 @@ declare const canonicalResolvedSchema: z.ZodObject<{
     sources: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         kind: z.ZodEnum<{
-            prefetch: "prefetch";
             manual: "manual";
+            prefetch: "prefetch";
             etl: "etl";
         }>;
         table: z.ZodString;
@@ -325,13 +325,13 @@ declare const canonicalColumnSchema: z.ZodObject<{
         bigint: "bigint";
         boolean: "boolean";
         date: "date";
-        uuid: "uuid";
         text: "text";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        jsonb: "jsonb";
     }>, z.ZodObject<{
         enum: z.ZodString;
     }, z.core.$strip>]>;
@@ -353,10 +353,10 @@ declare const canonicalColumnSchema: z.ZodObject<{
         of: z.ZodString;
         part: z.ZodEnum<{
             at: "at";
-            source: "source";
             by: "by";
-            conflicts: "conflicts";
             rev: "rev";
+            source: "source";
+            conflicts: "conflicts";
         }>;
     }, z.core.$strict>>;
 }, z.core.$strip>;
@@ -460,21 +460,21 @@ declare const canonicalActionSchema: z.ZodObject<{
             bigint: "bigint";
             boolean: "boolean";
             date: "date";
-            uuid: "uuid";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            jsonb: "jsonb";
         }>;
         nullable: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>>;
     executes: z.ZodString;
     returns: z.ZodDefault<z.ZodEnum<{
         rows: "rows";
-        scalar: "scalar";
         rowsAffected: "rowsAffected";
+        scalar: "scalar";
     }>>;
     audit: z.ZodOptional<z.ZodObject<{
         action: z.ZodString;
@@ -540,13 +540,13 @@ declare const canonicalTableSchema: z.ZodObject<{
             bigint: "bigint";
             boolean: "boolean";
             date: "date";
-            uuid: "uuid";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            jsonb: "jsonb";
         }>, z.ZodObject<{
             enum: z.ZodString;
         }, z.core.$strip>]>;
@@ -568,10 +568,10 @@ declare const canonicalTableSchema: z.ZodObject<{
             of: z.ZodString;
             part: z.ZodEnum<{
                 at: "at";
-                source: "source";
                 by: "by";
-                conflicts: "conflicts";
                 rev: "rev";
+                source: "source";
+                conflicts: "conflicts";
             }>;
         }, z.core.$strict>>;
     }, z.core.$strip>>>;
@@ -655,21 +655,21 @@ declare const canonicalTableSchema: z.ZodObject<{
                 bigint: "bigint";
                 boolean: "boolean";
                 date: "date";
-                uuid: "uuid";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                jsonb: "jsonb";
             }>;
             nullable: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>>;
         executes: z.ZodString;
         returns: z.ZodDefault<z.ZodEnum<{
             rows: "rows";
-            scalar: "scalar";
             rowsAffected: "rowsAffected";
+            scalar: "scalar";
         }>>;
         audit: z.ZodOptional<z.ZodObject<{
             action: z.ZodString;
@@ -726,13 +726,13 @@ declare const canonicalViewSchema: z.ZodObject<{
             bigint: "bigint";
             boolean: "boolean";
             date: "date";
-            uuid: "uuid";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            jsonb: "jsonb";
         }>, z.ZodObject<{
             enum: z.ZodString;
         }, z.core.$strip>]>;
@@ -754,10 +754,10 @@ declare const canonicalViewSchema: z.ZodObject<{
             of: z.ZodString;
             part: z.ZodEnum<{
                 at: "at";
-                source: "source";
                 by: "by";
-                conflicts: "conflicts";
                 rev: "rev";
+                source: "source";
+                conflicts: "conflicts";
             }>;
         }, z.core.$strict>>;
     }, z.core.$strip>>;
@@ -806,8 +806,8 @@ declare const canonicalViewSchema: z.ZodObject<{
         sources: z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             kind: z.ZodEnum<{
-                prefetch: "prefetch";
                 manual: "manual";
+                prefetch: "prefetch";
                 etl: "etl";
             }>;
             table: z.ZodString;
@@ -947,13 +947,13 @@ declare const localDefinitionSchema: z.ZodObject<{
                 bigint: "bigint";
                 boolean: "boolean";
                 date: "date";
-                uuid: "uuid";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                jsonb: "jsonb";
             }>, z.ZodObject<{
                 enum: z.ZodString;
             }, z.core.$strip>]>;
@@ -975,10 +975,10 @@ declare const localDefinitionSchema: z.ZodObject<{
                 of: z.ZodString;
                 part: z.ZodEnum<{
                     at: "at";
-                    source: "source";
                     by: "by";
-                    conflicts: "conflicts";
                     rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
                 }>;
             }, z.core.$strict>>;
         }, z.core.$strip>>>;
@@ -1062,21 +1062,21 @@ declare const localDefinitionSchema: z.ZodObject<{
                     bigint: "bigint";
                     boolean: "boolean";
                     date: "date";
-                    uuid: "uuid";
                     text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
                     integer: "integer";
                     numeric: "numeric";
                     double: "double";
-                    timestamptz: "timestamptz";
-                    jsonb: "jsonb";
                 }>;
                 nullable: z.ZodDefault<z.ZodBoolean>;
             }, z.core.$strip>>>;
             executes: z.ZodString;
             returns: z.ZodDefault<z.ZodEnum<{
                 rows: "rows";
-                scalar: "scalar";
                 rowsAffected: "rowsAffected";
+                scalar: "scalar";
             }>>;
             audit: z.ZodOptional<z.ZodObject<{
                 action: z.ZodString;
@@ -1132,13 +1132,13 @@ declare const localDefinitionSchema: z.ZodObject<{
                 bigint: "bigint";
                 boolean: "boolean";
                 date: "date";
-                uuid: "uuid";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                jsonb: "jsonb";
             }>, z.ZodObject<{
                 enum: z.ZodString;
             }, z.core.$strip>]>;
@@ -1160,10 +1160,10 @@ declare const localDefinitionSchema: z.ZodObject<{
                 of: z.ZodString;
                 part: z.ZodEnum<{
                     at: "at";
-                    source: "source";
                     by: "by";
-                    conflicts: "conflicts";
                     rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
                 }>;
             }, z.core.$strict>>;
         }, z.core.$strip>>;
@@ -1212,8 +1212,8 @@ declare const localDefinitionSchema: z.ZodObject<{
             sources: z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
                 kind: z.ZodEnum<{
-                    prefetch: "prefetch";
                     manual: "manual";
+                    prefetch: "prefetch";
                     etl: "etl";
                 }>;
                 table: z.ZodString;
@@ -1336,13 +1336,13 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 bigint: "bigint";
                 boolean: "boolean";
                 date: "date";
-                uuid: "uuid";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                jsonb: "jsonb";
             }>, z.ZodObject<{
                 enum: z.ZodString;
             }, z.core.$strip>]>;
@@ -1364,10 +1364,10 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 of: z.ZodString;
                 part: z.ZodEnum<{
                     at: "at";
-                    source: "source";
                     by: "by";
-                    conflicts: "conflicts";
                     rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
                 }>;
             }, z.core.$strict>>;
         }, z.core.$strip>>>;
@@ -1451,21 +1451,21 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                     bigint: "bigint";
                     boolean: "boolean";
                     date: "date";
-                    uuid: "uuid";
                     text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
                     integer: "integer";
                     numeric: "numeric";
                     double: "double";
-                    timestamptz: "timestamptz";
-                    jsonb: "jsonb";
                 }>;
                 nullable: z.ZodDefault<z.ZodBoolean>;
             }, z.core.$strip>>>;
             executes: z.ZodString;
             returns: z.ZodDefault<z.ZodEnum<{
                 rows: "rows";
-                scalar: "scalar";
                 rowsAffected: "rowsAffected";
+                scalar: "scalar";
             }>>;
             audit: z.ZodOptional<z.ZodObject<{
                 action: z.ZodString;
@@ -1521,13 +1521,13 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 bigint: "bigint";
                 boolean: "boolean";
                 date: "date";
-                uuid: "uuid";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                jsonb: "jsonb";
             }>, z.ZodObject<{
                 enum: z.ZodString;
             }, z.core.$strip>]>;
@@ -1549,10 +1549,10 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 of: z.ZodString;
                 part: z.ZodEnum<{
                     at: "at";
-                    source: "source";
                     by: "by";
-                    conflicts: "conflicts";
                     rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
                 }>;
             }, z.core.$strict>>;
         }, z.core.$strip>>;
@@ -1601,8 +1601,8 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             sources: z.ZodArray<z.ZodObject<{
                 name: z.ZodString;
                 kind: z.ZodEnum<{
-                    prefetch: "prefetch";
                     manual: "manual";
+                    prefetch: "prefetch";
                     etl: "etl";
                 }>;
                 table: z.ZodString;
@@ -1724,13 +1724,13 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                     bigint: "bigint";
                     boolean: "boolean";
                     date: "date";
-                    uuid: "uuid";
                     text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
                     integer: "integer";
                     numeric: "numeric";
                     double: "double";
-                    timestamptz: "timestamptz";
-                    jsonb: "jsonb";
                 }>, z.ZodObject<{
                     enum: z.ZodString;
                 }, z.core.$strip>]>;
@@ -1752,10 +1752,10 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                     of: z.ZodString;
                     part: z.ZodEnum<{
                         at: "at";
-                        source: "source";
                         by: "by";
-                        conflicts: "conflicts";
                         rev: "rev";
+                        source: "source";
+                        conflicts: "conflicts";
                     }>;
                 }, z.core.$strict>>;
             }, z.core.$strip>>>;
@@ -1839,21 +1839,21 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                         bigint: "bigint";
                         boolean: "boolean";
                         date: "date";
-                        uuid: "uuid";
                         text: "text";
+                        timestamptz: "timestamptz";
+                        jsonb: "jsonb";
+                        uuid: "uuid";
                         integer: "integer";
                         numeric: "numeric";
                         double: "double";
-                        timestamptz: "timestamptz";
-                        jsonb: "jsonb";
                     }>;
                     nullable: z.ZodDefault<z.ZodBoolean>;
                 }, z.core.$strip>>>;
                 executes: z.ZodString;
                 returns: z.ZodDefault<z.ZodEnum<{
                     rows: "rows";
-                    scalar: "scalar";
                     rowsAffected: "rowsAffected";
+                    scalar: "scalar";
                 }>>;
                 audit: z.ZodOptional<z.ZodObject<{
                     action: z.ZodString;
@@ -1909,13 +1909,13 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                     bigint: "bigint";
                     boolean: "boolean";
                     date: "date";
-                    uuid: "uuid";
                     text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
                     integer: "integer";
                     numeric: "numeric";
                     double: "double";
-                    timestamptz: "timestamptz";
-                    jsonb: "jsonb";
                 }>, z.ZodObject<{
                     enum: z.ZodString;
                 }, z.core.$strip>]>;
@@ -1937,10 +1937,10 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                     of: z.ZodString;
                     part: z.ZodEnum<{
                         at: "at";
-                        source: "source";
                         by: "by";
-                        conflicts: "conflicts";
                         rev: "rev";
+                        source: "source";
+                        conflicts: "conflicts";
                     }>;
                 }, z.core.$strict>>;
             }, z.core.$strip>>;
@@ -1989,8 +1989,8 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 sources: z.ZodArray<z.ZodObject<{
                     name: z.ZodString;
                     kind: z.ZodEnum<{
-                        prefetch: "prefetch";
                         manual: "manual";
+                        prefetch: "prefetch";
                         etl: "etl";
                     }>;
                     table: z.ZodString;

package/dist/cli.cjs

@@ -6007,7 +6007,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;
@@ -6022,7 +6022,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 })}`,
       ""
     );
   }
@@ -6812,29 +6812,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 = zod.z.object({
   capability: zod.z.string().min(1).optional(),
   role: zod.z.string().min(1).optional()
 }).nullable();
 var manifestOperationSchema = zod.z.object({
-  hash: zod.z.string().regex(OP_HASH_RE),
   kind: zod.z.enum(["query", "mutation"]),
   requires: manifestRequiresSchema
 });
 var operationsManifestSchema = zod.z.object({
-  manifestVersion: zod.z.literal(MANIFEST_VERSION),
-  schemaHash: zod.z.string().min(1),
-  opsHash: zod.z.string().regex(OP_HASH_RE),
+  manifestVersion: zod.z.union([zod.z.literal(1), zod.z.literal(MANIFEST_VERSION)]),
   operations: zod.z.record(zod.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) => {
@@ -6845,20 +6839,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:${crypto.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
   };
 }
@@ -11688,11 +11676,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 promises.writeFile(path.join(dir, OPERATIONS_MANIFEST_FILE), `${JSON.stringify(manifestFile, null, 2)}
 `);
   await promises.writeFile(path.join(dir, TYPE_POLICIES_FILE), generateTypePolicies(loaded.canonical));
@@ -11805,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;
@@ -11819,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",
@@ -11842,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) {