@sequenceholdings/orm 2.7.1 → 2.8.2

package/dist/sdl.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var zod = require('zod');
-var crypto = require('crypto');
+require('crypto');
 
 // src/canonical/v2.ts
 var quoteIdentifier = (name) => `"${name.replaceAll('"', '""')}"`;
@@ -1802,7 +1802,7 @@ var PLATFORM_USER_FIELDS = [
 ];
 function generateSdl(canonical, options = {}) {
   const def = composeNamespace(normalizeCanonical(canonicalDefinitionSchema.parse(canonical))).definition;
-  const exposed = canonicalRelations(def).filter((table) => table.source === void 0 && table.internal !== true);
+  const exposed = canonicalRelations(def).filter((table) => table.internal !== true && (table.source === void 0 || options.includeSyncedReads === true && (table.primaryKey?.length ?? 0) > 0));
   const cellsByTable = new Map(exposed.map((table) => [table.table, trackedCells(table)]));
   const tables = exposed.map((table) => ({ ...table, columns: table.columns.filter((column) => column.cell === void 0) }));
   if (tables.length === 0) {
@@ -2112,10 +2112,10 @@ function renderResolvedMutationFields(table, names) {
   return lines;
 }
 function allowsInsert(table) {
-  return table.policies.write !== void 0 || table.policies.insert !== void 0;
+  return table.source === void 0 && (table.policies.write !== void 0 || table.policies.insert !== void 0);
 }
 function allowsUpdate(table) {
-  return table.policies.write !== void 0 || table.policies.update !== void 0;
+  return table.source === void 0 && (table.policies.write !== void 0 || table.policies.update !== void 0);
 }
 function allowsOnConflict(table) {
   if (!allowsInsert(table) || !allowsUpdate(table)) return false;
@@ -2459,29 +2459,23 @@ var CodegenGqlError = class extends Error {
 };
 
 // src/codegen-gql/manifest.ts
-var MANIFEST_VERSION = 1;
-var OP_HASH_RE = /^sha256:[0-9a-f]{64}$/;
+var MANIFEST_VERSION = 2;
 var GRAPHQL_NAME_RE2 = /^[_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_RE2), 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) => {
@@ -2492,20 +2486,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
   };
 }