@sequenceholdings/orm 2.11.0 → 2.11.1

package/dist/compiler.cjs

@@ -2137,9 +2137,6 @@ function normalizeCanonical(definition) {
   return normalized;
 }
 
-// src/client/sql.ts
-var BUILTIN_SQL_READ_HASH = "sha256:a50c477c952a5e0fe68ed158a4530e4aab573c09bcbb1a8ac454dc88a39a6258";
-
 // src/ir/index.ts
 var IR_VERSION = 6;
 var LEGACY_IR_VERSION = 1;
@@ -2468,8 +2465,7 @@ var compiledOperationSchema = zod.z.object({
     maxRows: zod.z.number().int().min(1).max(1e4)
   }).strict().optional(),
   irVersion: irVersionSchema,
-  name: zod.z.string(),
-  opHash: zod.z.string().regex(/^sha256:[0-9a-f]{64}$/),
+  name: zod.z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: zod.z.enum(["query", "mutation"]),
   requires: zod.z.object({
     capability: zod.z.string().optional(),
@@ -2485,7 +2481,7 @@ var compiledOperationSchema = zod.z.object({
   }
   if (operation.language === "sql") {
     const validPlan = operation.sqlQuery ? !operation.sql && operation.irVersion === RUNTIME_SQL_IR_VERSION : !!operation.sql && operation.irVersion === SQL_IR_VERSION;
-    const builtin = operation.name === "BuiltinSqlRead" && operation.opHash === BUILTIN_SQL_READ_HASH && operation.requires === null;
+    const builtin = operation.name === "BuiltinSqlRead" && operation.requires === null;
     if (!validPlan || operation.kind !== "query" || operation.roots.length !== 0 || !builtin && !operation.requires?.capability) {
       ctx.addIssue({ code: "custom", message: "SQL operations require a query-only v4 plan or v5 runtime contract, capability, and no GraphQL roots" });
     }
@@ -2500,7 +2496,7 @@ var compiledOperationSchema = zod.z.object({
   }
 });
 var resolvedSourceIrSchema = zod.z.object({
-  name: zod.z.string(),
+  name: zod.z.string().regex(/^[_A-Za-z][_0-9A-Za-z]{0,254}$/),
   kind: zod.z.enum(["manual", "etl", "prefetch"]),
   /** Logical table key of the backing relation. */
   table: zod.z.string(),
@@ -2614,7 +2610,6 @@ var compiledArtifactSchema = zod.z.object({
   ownSchemaHash: zod.z.string().optional(),
   dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
   readPolicies: zod.z.record(zod.z.string(), predIrSchema).optional(),
-  opsHash: zod.z.string(),
   /** Apply-observed synced objects without a serving backing; not part of the authored schema hash. */
   unbackedTables: zod.z.array(zod.z.string()).optional(),
   tables: zod.z.record(zod.z.string(), tableMetaIrSchema),
@@ -4319,24 +4314,6 @@ function flattenOperation({
 }) {
   return { ...operation, selectionSet: flattenSelectionSet(operation.selectionSet, fragments, []) };
 }
-var COMPILER_MAJOR = 1;
-var OP_HASH_DOMAIN = "sequence-orm-op\0";
-var OPS_HASH_DOMAIN = "sequence-orm-opset\0";
-function canonicalOperationText(definition) {
-  const document2 = { kind: graphql.Kind.DOCUMENT, definitions: [definition] };
-  return graphql.print(document2);
-}
-function computeOpHash({
-  definition,
-  schemaHash
-}) {
-  const digest2 = crypto.createHash("sha256").update(OP_HASH_DOMAIN).update(`${COMPILER_MAJOR}\0${schemaHash}\0`).update(canonicalOperationText(definition)).digest("hex");
-  return `sha256:${digest2}`;
-}
-function computeOpsHash(opHashes) {
-  const digest2 = crypto.createHash("sha256").update(OPS_HASH_DOMAIN).update([...opHashes].sort().join("\n")).digest("hex");
-  return `sha256:${digest2}`;
-}
 var SOURCE_DIRECTIVES = /* @__PURE__ */ new Set(["prefetch", "writeback", "localOnly"]);
 var fail = (message, code) => {
   throw new DocumentCompileError(message, code);
@@ -5832,7 +5809,6 @@ function compileNamespace({ canonical, sdl, documents }) {
         operations[restricted.name] = {
           irVersion: usesServicePrincipal(roots) ? SERVICE_PRINCIPAL_IR_VERSION : canonical.imports?.length ? COMPOSED_IR_VERSION : roots.some((root) => root.kind === "mutation" && root.assertAffectedRows !== void 0) ? GUARDED_IR_VERSION : LEGACY_IR_VERSION,
           name: restricted.name,
-          opHash: computeOpHash({ definition: flattened, schemaHash }),
           kind: restricted.kind,
           requires: restricted.requires,
           variables: restricted.variables,
@@ -5865,7 +5841,6 @@ function compileNamespace({ canonical, sdl, documents }) {
       dependencies: Object.fromEntries(canonical.imports.map((owner) => [owner.namespace, computeSchemaHash(localContract(owner))]))
     } : {},
     readPolicies: Object.fromEntries(ctx.readPolicies),
-    opsHash: computeOpsHash(Object.values(operations).map((op) => op.opHash)),
     tables: ctx.tables,
     operations
   };
@@ -5873,11 +5848,10 @@ function compileNamespace({ canonical, sdl, documents }) {
   const manifest = {
     namespace: ctx.namespace,
     schemaHash,
-    opsHash: normalized.opsHash,
     operations: Object.fromEntries(
       Object.values(normalized.operations).map((op) => [
         op.name,
-        { opHash: op.opHash, kind: op.kind, requires: op.requires }
+        op
       ])
     )
   };
@@ -6273,6 +6247,10 @@ function validateOnConflictInput({
   }
   return finish(collector, { constraint, updateColumns });
 }
+function canonicalOperationText(definition) {
+  const document2 = { kind: graphql.Kind.DOCUMENT, definitions: [definition] };
+  return graphql.print(document2);
+}
 
 // src/sdl/generate.ts
 var SdlGenerationError = class extends Error {
@@ -7251,7 +7229,6 @@ function createSqlCatalog({ canonical, publishedObjects, executionTarget }) {
 }
 function createSqlCatalogFromContext({ canonical, publishedObjects, executionTarget, ctx, identity: suppliedIdentity }) {
   if (!publishedObjects.length || new Set(publishedObjects).size !== publishedObjects.length) throw new Error("SQL objects must be explicitly declared and unique");
-  const identity = suppliedIdentity ?? sqlHash(`ontology-sql-v1\0${computeSchemaHash(canonical)}\0${executionTarget}`);
   const logicalNames = new Map(Object.entries(ctx.tables).map(([key, meta]) => [meta, key]));
   const refOf = (meta) => `${meta.namespace ?? canonical.namespace}/${logicalNames.get(meta)}`;
   const definitions = [canonical, ...canonical.imports ?? []];
@@ -7276,7 +7253,7 @@ function createSqlCatalogFromContext({ canonical, publishedObjects, executionTar
     const scan = `SELECT ${projection} FROM ${quoteIdentifier(meta.schema)}.${quoteIdentifier(meta.table)} AS ${quoteIdentifier("p0")} WHERE ${compileStaticPolicySql({ table: meta, predicate: policy, tables: ctx.tables, namespace: canonical.namespace, alias: "p0", onRead: (target) => reads.add(refOf(target)) })}`;
     return { ref, table: meta.table, columns, scan, read: [...reads].sort() };
   });
-  return { identity, objects };
+  return { identity: suppliedIdentity ?? sqlHash(JSON.stringify(["ontology-sql-catalog-v2", executionTarget, objects])), objects };
 }
 
 // src/sql/ast.ts
@@ -7830,20 +7807,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
       const catalog = createSqlCatalog({ canonical: input.canonical, publishedObjects: read, executionTarget: "registered-operation" });
       if ("mode" in definition) {
         if (catalog.objects.some((object) => object.read.some((ref) => !read.includes(ref)))) throw new Error("SQL policy accesses an undeclared ontology object");
-        const opHash2 = sqlHash(JSON.stringify([
-          "sequence-runtime-sql-operation-v1",
-          definition.name,
-          definition.namespace,
-          definition.requires.capability,
-          read,
-          catalog.identity,
-          definition.maxRows
-        ]));
         result.artifact.operations[definition.name] = compiledOperationSchema.parse({
           irVersion: RUNTIME_SQL_IR_VERSION,
           language: "sql",
           name: definition.name,
-          opHash: opHash2,
           kind: "query",
           requires: definition.requires,
           variables: [
@@ -7854,7 +7821,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
           tableSet: read.map((ref) => ref.split("/")[1]).sort(),
           sqlQuery: { catalog, read, maxRows: definition.maxRows }
         });
-        result.manifest.operations[definition.name] = { opHash: opHash2, kind: "query", requires: definition.requires };
+        result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
         continue;
       }
       const names = Object.keys(definition.parameters).sort();
@@ -7872,20 +7839,10 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         nullable: !definition.parameters[name2].required,
         list: false
       }));
-      const opHash = sqlHash(JSON.stringify([
-        "sequence-sql-operation-v1",
-        definition.name,
-        definition.namespace,
-        definition.requires.capability,
-        read,
-        variables,
-        plan.queryHash
-      ]));
       const operation = compiledOperationSchema.parse({
         irVersion: SQL_IR_VERSION,
         language: "sql",
         name: definition.name,
-        opHash,
         kind: "query",
         requires: definition.requires,
         variables,
@@ -7894,7 +7851,7 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
         sql: { text: plan.text, columns: plan.columns, parameters: names, read, maxRows: plan.maxRows }
       });
       result.artifact.operations[definition.name] = operation;
-      result.manifest.operations[definition.name] = { opHash, kind: "query", requires: definition.requires };
+      result.manifest.operations[definition.name] = result.artifact.operations[definition.name];
     } catch (error) {
       return { ok: false, diagnostics: [...result.diagnostics, {
         severity: "error",
@@ -7906,8 +7863,6 @@ async function compileSqlDocuments({ input, result, sqlDocuments }) {
   }
   const required = requiredArtifactIrVersion(Object.values(result.artifact.operations));
   if (required > result.artifact.irVersion) result.artifact.irVersion = required;
-  result.artifact.opsHash = computeOpsHash(Object.values(result.artifact.operations).map((op) => op.opHash));
-  result.manifest.opsHash = result.artifact.opsHash;
   return { ...result, artifact: normalizeIr(result.artifact) };
 }
 async function managedViewDiagnostics(canonical) {
@@ -8006,14 +7961,13 @@ function compileBuiltinSqlArtifact({ namespace, definitions, read, unbackedObjec
     namespace,
     executionTarget,
     read,
-    definitions.map((definition) => [definition.namespace, computeSchemaHash(definition)]).sort()
+    objects
   ])) };
   return normalizeIr({
     irVersion: usesServicePrincipal(policies) ? SERVICE_PRINCIPAL_IR_VERSION : RUNTIME_SQL_IR_VERSION,
     namespace,
     schemaHash: catalog.identity,
     ownSchemaHash: localHash(anchor),
-    opsHash: BUILTIN_SQL_READ_HASH,
     dependencies: Object.fromEntries(definitions.filter((definition) => definition.namespace !== namespace).map((definition) => [definition.namespace, localHash(definition)])),
     tables,
     readPolicies: policies,
@@ -8021,7 +7975,6 @@ function compileBuiltinSqlArtifact({ namespace, definitions, read, unbackedObjec
     operations: { BuiltinSqlRead: {
       irVersion: RUNTIME_SQL_IR_VERSION,
       name: "BuiltinSqlRead",
-      opHash: BUILTIN_SQL_READ_HASH,
       language: "sql",
       kind: "query",
       requires: null,
@@ -8186,13 +8139,11 @@ function composeObjectSqlArtifact({ namespace, bundles }) {
     irVersion: usesServicePrincipal(readPolicies) ? SERVICE_PRINCIPAL_IR_VERSION : RUNTIME_SQL_IR_VERSION,
     namespace,
     schemaHash: identity,
-    opsHash: BUILTIN_SQL_READ_HASH,
     tables,
     readPolicies,
     operations: { BuiltinSqlRead: {
       irVersion: RUNTIME_SQL_IR_VERSION,
       name: "BuiltinSqlRead",
-      opHash: BUILTIN_SQL_READ_HASH,
       language: "sql",
       kind: "query",
       requires: null,
@@ -8206,12 +8157,13 @@ function composeObjectSqlArtifact({ namespace, bundles }) {
     } }
   });
 }
+
+// src/compiler-gql/dataset-previews.ts
 var DATASET_PREVIEW_LIMIT = 100;
 function compileDatasetPreviews(input) {
   const canonical = normalizeCanonical(input);
   const { ctx, diagnostics } = buildCompileContext(canonical);
   if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) throw new NamespaceCompileError(diagnostics);
-  const schemaHash = computeSchemaHash(canonical);
   const operations = {};
   for (const relation of canonicalRelations(canonical)) {
     if (relation.internal || relation.source !== void 0) continue;
@@ -8236,11 +8188,9 @@ function compileDatasetPreviews(input) {
         throw new DocumentCompileError(`object '${meta.namespace}/${table}' is not exported for reads`, "unexported-object");
       }
     }
-    const hash = crypto.createHash("sha256").update("sequence-orm-dataset-preview-v1\0").update(stableJson({ schemaHash, roots, tableSet })).digest("hex");
     operations[relation.table] = compiledOperationSchema.parse({
       irVersion: usesServicePrincipal(roots) ? SERVICE_PRINCIPAL_IR_VERSION : canonical.imports?.length ? COMPOSED_IR_VERSION : LEGACY_IR_VERSION,
       name: `DatasetPreview_${relation.table}`,
-      opHash: `sha256:${hash}`,
       kind: "query",
       requires: null,
       variables: [],
@@ -8309,7 +8259,6 @@ function projectOperationMetadata({ artifact, operation }) {
   });
 }
 
-exports.COMPILER_MAJOR = COMPILER_MAJOR;
 exports.CONST_TRUE = CONST_TRUE;
 exports.DATASET_PREVIEW_LIMIT = DATASET_PREVIEW_LIMIT;
 exports.DEFAULT_LIMIT = DEFAULT_LIMIT;
@@ -8347,8 +8296,6 @@ exports.compilePolicy = compilePolicy;
 exports.compilePredicateV2 = compilePredicateV2;
 exports.compileRuntimeSql = compileRuntimeSql;
 exports.composeObjectSqlArtifact = composeObjectSqlArtifact;
-exports.computeOpHash = computeOpHash;
-exports.computeOpsHash = computeOpsHash;
 exports.computePinnedColumnsByTable = computePinnedColumnsByTable;
 exports.computeSchemaHash = computeSchemaHash;
 exports.defineOperation = defineOperation;