@secondlayer/subgraphs 4.4.1 → 5.0.0

package/dist/{src/schema → schema}/index.js

@@ -1,5 +1,171 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+// src/schema/generator.ts
+import { createHash } from "node:crypto";
+
+// src/schema/utils.ts
+import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
+function quotePgIdent(name) {
+  if (/^[a-z_][a-z0-9_]*$/i.test(name))
+    return name;
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function snakeToCamel(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascalCase(name) {
+  const camel = snakeToCamel(name);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+// src/schema/generator.ts
+var TYPE_MAP = {
+  text: "TEXT",
+  uint: "NUMERIC",
+  int: "NUMERIC",
+  principal: "TEXT",
+  boolean: "BOOLEAN",
+  timestamp: "TIMESTAMPTZ",
+  jsonb: "JSONB"
+};
+var MAX_IDENT_BYTES = 63;
+function safeIndexName(name) {
+  if (name.length <= MAX_IDENT_BYTES)
+    return name;
+  const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
+  return `${name.slice(0, MAX_IDENT_BYTES - hash.length - 1)}_${hash}`;
+}
+function emitIndexedColumnIndexDDL(schemaName, tableName, colName, opts) {
+  const concurrently = opts?.concurrently ? " CONCURRENTLY" : "";
+  const qualified = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
+  const plain = `idx_${schemaName}_${tableName}_${colName}`;
+  const composite = safeIndexName(`idx_${schemaName}_${tableName}_${colName}_id`);
+  const col = quotePgIdent(colName);
+  const id = quotePgIdent("_id");
+  return {
+    create: [
+      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(plain)} ON ${qualified} (${col})`,
+      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(composite)} ON ${qualified} (${col}, ${id})`
+    ],
+    drop: [
+      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(plain)}`,
+      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(composite)}`
+    ]
+  };
+}
+function escapeLiteralDefault(value) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function tableNeedsTrgm(tableDef) {
+  return Object.values(tableDef.columns).some((col) => col.search);
+}
+function emitTableDDL(schemaName, tableName, tableDef) {
+  const qualifiedName = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
+  const statements = [];
+  const columnDefs = [
+    "_id BIGSERIAL PRIMARY KEY",
+    "_block_height BIGINT NOT NULL",
+    "_tx_id TEXT NOT NULL",
+    "_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()"
+  ];
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    const sqlType = TYPE_MAP[col.type];
+    const nullable = col.nullable ? "" : " NOT NULL";
+    let colDef = `${quotePgIdent(colName)} ${sqlType}${nullable}`;
+    if (col.default !== undefined) {
+      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
+    }
+    if (col.type === "uint") {
+      colDef += ` CHECK (${quotePgIdent(colName)} >= 0)`;
+    }
+    columnDefs.push(colDef);
+  }
+  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
+  ${columnDefs.join(`,
+  `)}
+)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_block_height`)} ON ${qualifiedName} (_block_height)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_tx_id`)} ON ${qualifiedName} (_tx_id)`);
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.indexed) {
+      statements.push(...emitIndexedColumnIndexDDL(schemaName, tableName, colName).create);
+    }
+  }
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.search) {
+      statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_${colName}_trgm`)} ON ${qualifiedName} USING gin (${quotePgIdent(colName)} gin_trgm_ops)`);
+    }
+  }
+  if (tableDef.indexes) {
+    for (let i = 0;i < tableDef.indexes.length; i++) {
+      const cols = tableDef.indexes[i];
+      const idxName = quotePgIdent(`idx_${schemaName}_${tableName}_composite_${i}`);
+      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.map(quotePgIdent).join(", ")})`);
+    }
+  }
+  if (tableDef.uniqueKeys) {
+    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
+      const cols = tableDef.uniqueKeys[i];
+      const constraintName = quotePgIdent(`uq_${schemaName}_${tableName}_${cols.join("_")}`);
+      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.map(quotePgIdent).join(", ")})`);
+    }
+  }
+  return statements;
+}
+function emitJournalDDL(schemaName) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${schemaName}._journal (
+  _jid BIGSERIAL PRIMARY KEY,
+  block_height BIGINT NOT NULL,
+  table_name TEXT NOT NULL,
+  row_key JSONB NOT NULL,
+  prev_row JSONB,
+  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+)`,
+    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_journal_height ON ${schemaName}._journal (block_height)`
+  ];
+}
+function emitFactoryDDL(schemaName) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${schemaName}._factory_addresses (
+  source_name TEXT NOT NULL,
+  address TEXT NOT NULL,
+  block_height BIGINT NOT NULL,
+  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (source_name, address)
+)`,
+    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
+  ];
+}
+function generateSubgraphSQL(def, schemaNameOverride) {
+  const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
+  const statements = [];
+  const needsTrgm = Object.values(def.schema).some((table) => Object.values(table.columns).some((col) => col.search));
+  if (needsTrgm) {
+    statements.push("CREATE EXTENSION IF NOT EXISTS pg_trgm");
+  }
+  statements.push(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
+  for (const [tableName, tableDef] of Object.entries(def.schema)) {
+    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
+  }
+  statements.push(...emitJournalDDL(schemaName));
+  if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
+    statements.push(...emitFactoryDDL(schemaName));
+  }
+  const hashInput = JSON.stringify({
+    name: def.name,
+    schema: def.schema,
+    sources: def.sources
+  }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+  const hash = createHash("sha256").update(hashInput).digest("hex");
+  return { statements, hash };
+}
+// src/schema/deployer.ts
+import { sql } from "kysely";
 
 // src/validate.ts
 import { z } from "zod";
@@ -62,13 +228,7 @@ var SubgraphColumnSchema = z.object({
 var SubgraphTableSchema = z.object({
   columns: z.record(SqlIdentifierSchema, SubgraphColumnSchema).refine((c) => Object.keys(c).length > 0, "Table must have at least one column"),
   indexes: z.array(z.array(SqlIdentifierSchema)).optional(),
-  uniqueKeys: z.array(z.array(SqlIdentifierSchema)).optional(),
-  relations: z.array(z.object({
-    name: SqlIdentifierSchema,
-    references: SqlIdentifierSchema,
-    fields: z.array(SqlIdentifierSchema).min(1),
-    referencedColumns: z.array(SqlIdentifierSchema).min(1)
-  })).optional()
+  uniqueKeys: z.array(z.array(SqlIdentifierSchema)).optional()
 });
 var SubgraphSchemaSchema = z.record(SqlIdentifierSchema, SubgraphTableSchema).refine((s) => Object.keys(s).length > 0, "Schema must have at least one table");
 var VALID_FILTER_TYPES = [
@@ -103,15 +263,6 @@ var amountRange = {
   minAmount: z.bigint().optional(),
   maxAmount: z.bigint().optional()
 };
-var MaterializeColumnSchema = z.union([
-  z.object({ from: z.string().min(1) }).strict(),
-  z.object({ fromTx: z.enum(["sender", "txId"]) }).strict(),
-  z.object({ fromBlock: z.enum(["height", "hash", "timestamp"]) }).strict()
-]);
-var MaterializeSpecSchema = z.object({
-  table: z.string().min(1),
-  columns: z.record(z.string(), MaterializeColumnSchema)
-}).strict();
 var SubgraphFilterUnion = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("stx_transfer"),
@@ -194,7 +345,6 @@ var SubgraphFilterUnion = z.discriminatedUnion("type", [
     contractId: contractIdField.optional(),
     topic: z.string().optional(),
     prints: z.record(z.string(), z.record(z.string(), PrintFieldSchema)).optional(),
-    materialize: MaterializeSpecSchema.optional(),
     ...traitScope,
     ...factoryScope
   }).strict(),
@@ -244,54 +394,6 @@ function hasPinnedContractId(contractId) {
     return contractId.length > 0;
   return false;
 }
-function printMaterializeFromKeys(prints) {
-  const keys = new Set(["topic"]);
-  if (prints) {
-    for (const fields of Object.values(prints)) {
-      for (const k of Object.keys(fields))
-        keys.add(k);
-    }
-  }
-  return [...keys].sort();
-}
-function refineMaterialize(name, filter, schema, ctx) {
-  if (!("materialize" in filter) || filter.materialize === undefined)
-    return;
-  const spec = filter.materialize;
-  const table = schema[spec.table];
-  if (!table) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["sources", name, "materialize", "table"],
-      message: `materialize table "${spec.table}" is not in schema`
-    });
-    return;
-  }
-  for (const col of Object.keys(spec.columns)) {
-    if (!(col in table.columns)) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["sources", name, "materialize", "columns", col],
-        message: `materialize column "${col}" is not on schema table "${spec.table}"`
-      });
-    }
-  }
-  if (filter.type === "print_event") {
-    const known = printMaterializeFromKeys(filter.prints);
-    const knownSet = new Set(known);
-    for (const [col, mapping] of Object.entries(spec.columns)) {
-      if (!("from" in mapping))
-        continue;
-      if (!knownSet.has(mapping.from)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["sources", name, "materialize", "columns", col, "from"],
-          message: `materialize from "${mapping.from}" is not a known print field — known: ${known.join(", ")}`
-        });
-      }
-    }
-  }
-}
 function refineDeployGates(def, ctx) {
   for (const [name, filter] of Object.entries(def.sources)) {
     if (filter.type === "print_event") {
@@ -312,36 +414,23 @@ function refineDeployGates(def, ctx) {
         ctx.addIssue({
           code: "custom",
           path: ["sources", name, "abi"],
-          message: `contract_call source "${name}" has functionName but no abi — pass a canonical ABI (normalizeAbi() from @secondlayer/stacks/clarity).`
+          message: `contract_call source "${name}" has functionName but no abi. \`secondlayer subgraphs deploy\` fills it in from the deployed contract; otherwise pass abi (normalizeAbi() from @secondlayer/stacks/clarity).`
         });
       }
     }
-    refineMaterialize(name, filter, def.schema, ctx);
   }
-  const hasCatchAll = def.handlers["*"] != null;
-  for (const [name, filter] of Object.entries(def.sources)) {
-    const hasMaterialize = "materialize" in filter && filter.materialize !== undefined;
-    const hasHandler = def.handlers[name] != null;
-    if (hasMaterialize && hasHandler) {
-      ctx.addIssue({
-        code: "custom",
-        path: ["handlers", name],
-        message: `source "${name}" has both materialize and a handler — use one or the other`
-      });
-      continue;
-    }
-    if (!hasHandler && !hasMaterialize && !hasCatchAll) {
+  for (const name of Object.keys(def.sources)) {
+    if (def.handlers[name] == null) {
       ctx.addIssue({
         code: "custom",
         path: ["handlers", name],
-        message: `source "${name}" has no handler (and no "*") — events will be skipped and the table stay empty.`
+        message: `source "${name}" has no handler. Add handlers.${name}, or its events are skipped and the table stays empty.`
       });
     }
   }
 }
 var SubgraphDefinitionSchema = z.object({
   name: SubgraphNameSchema,
-  version: z.string().optional(),
   description: z.string().optional(),
   startBlock: z.number().int().nonnegative().optional(),
   backfillMode: z.enum(["blocking", "concurrent"]).optional(),
@@ -372,183 +461,7 @@ function filterFieldsByType() {
   return out;
 }
 
-// src/schema/generator.ts
-import { createHash } from "node:crypto";
-
-// src/schema/utils.ts
-import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
-function quotePgIdent(name) {
-  if (/^[a-z_][a-z0-9_]*$/i.test(name))
-    return name;
-  return `"${name.replace(/"/g, '""')}"`;
-}
-function snakeToCamel(name) {
-  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
-function pascalCase(name) {
-  const camel = snakeToCamel(name);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-
-// src/schema/generator.ts
-var TYPE_MAP = {
-  text: "TEXT",
-  uint: "NUMERIC",
-  int: "NUMERIC",
-  principal: "TEXT",
-  boolean: "BOOLEAN",
-  timestamp: "TIMESTAMPTZ",
-  jsonb: "JSONB"
-};
-var MAX_IDENT_BYTES = 63;
-function safeIndexName(name) {
-  if (name.length <= MAX_IDENT_BYTES)
-    return name;
-  const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
-  return `${name.slice(0, MAX_IDENT_BYTES - hash.length - 1)}_${hash}`;
-}
-function emitIndexedColumnIndexDDL(schemaName, tableName, colName, opts) {
-  const concurrently = opts?.concurrently ? " CONCURRENTLY" : "";
-  const qualified = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
-  const plain = `idx_${schemaName}_${tableName}_${colName}`;
-  const composite = safeIndexName(`idx_${schemaName}_${tableName}_${colName}_id`);
-  const col = quotePgIdent(colName);
-  const id = quotePgIdent("_id");
-  return {
-    create: [
-      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(plain)} ON ${qualified} (${col})`,
-      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(composite)} ON ${qualified} (${col}, ${id})`
-    ],
-    drop: [
-      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(plain)}`,
-      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(composite)}`
-    ]
-  };
-}
-function escapeLiteralDefault(value) {
-  if (value === null || value === undefined)
-    return "NULL";
-  if (typeof value === "number" || typeof value === "bigint")
-    return String(value);
-  if (typeof value === "boolean")
-    return value ? "TRUE" : "FALSE";
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-function tableNeedsTrgm(tableDef) {
-  return Object.values(tableDef.columns).some((col) => col.search);
-}
-function emitTableDDL(schemaName, tableName, tableDef) {
-  const qualifiedName = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
-  const statements = [];
-  const columnDefs = [
-    "_id BIGSERIAL PRIMARY KEY",
-    "_block_height BIGINT NOT NULL",
-    "_tx_id TEXT NOT NULL",
-    "_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()"
-  ];
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    const sqlType = TYPE_MAP[col.type];
-    const nullable = col.nullable ? "" : " NOT NULL";
-    let colDef = `${quotePgIdent(colName)} ${sqlType}${nullable}`;
-    if (col.default !== undefined) {
-      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
-    }
-    if (col.type === "uint") {
-      colDef += ` CHECK (${quotePgIdent(colName)} >= 0)`;
-    }
-    columnDefs.push(colDef);
-  }
-  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
-  ${columnDefs.join(`,
-  `)}
-)`);
-  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_block_height`)} ON ${qualifiedName} (_block_height)`);
-  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_tx_id`)} ON ${qualifiedName} (_tx_id)`);
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    if (col.indexed) {
-      statements.push(...emitIndexedColumnIndexDDL(schemaName, tableName, colName).create);
-    }
-  }
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    if (col.search) {
-      statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_${colName}_trgm`)} ON ${qualifiedName} USING gin (${quotePgIdent(colName)} gin_trgm_ops)`);
-    }
-  }
-  if (tableDef.indexes) {
-    for (let i = 0;i < tableDef.indexes.length; i++) {
-      const cols = tableDef.indexes[i];
-      const idxName = quotePgIdent(`idx_${schemaName}_${tableName}_composite_${i}`);
-      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.map(quotePgIdent).join(", ")})`);
-    }
-  }
-  if (tableDef.uniqueKeys) {
-    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
-      const cols = tableDef.uniqueKeys[i];
-      const constraintName = quotePgIdent(`uq_${schemaName}_${tableName}_${cols.join("_")}`);
-      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.map(quotePgIdent).join(", ")})`);
-    }
-  }
-  return statements;
-}
-function emitJournalDDL(schemaName) {
-  return [
-    `CREATE TABLE IF NOT EXISTS ${schemaName}._journal (
-  _jid BIGSERIAL PRIMARY KEY,
-  block_height BIGINT NOT NULL,
-  table_name TEXT NOT NULL,
-  row_key JSONB NOT NULL,
-  prev_row JSONB,
-  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-)`,
-    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_journal_height ON ${schemaName}._journal (block_height)`
-  ];
-}
-function emitFactoryDDL(schemaName) {
-  return [
-    `CREATE TABLE IF NOT EXISTS ${schemaName}._factory_addresses (
-  source_name TEXT NOT NULL,
-  address TEXT NOT NULL,
-  block_height BIGINT NOT NULL,
-  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  PRIMARY KEY (source_name, address)
-)`,
-    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
-  ];
-}
-function emitForeignKeyDDL(schemaName, tableName, tableDef) {
-  return (tableDef.relations ?? []).map((rel) => {
-    const constraintName = quotePgIdent(`fk_${schemaName}_${tableName}_${rel.name}`);
-    return `ALTER TABLE ${quotePgIdent(schemaName)}.${quotePgIdent(tableName)} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.map(quotePgIdent).join(", ")}) ` + `REFERENCES ${quotePgIdent(schemaName)}.${quotePgIdent(rel.references)} (${rel.referencedColumns.map(quotePgIdent).join(", ")})`;
-  });
-}
-function generateSubgraphSQL(def, schemaNameOverride) {
-  const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
-  const statements = [];
-  const needsTrgm = Object.values(def.schema).some((table) => Object.values(table.columns).some((col) => col.search));
-  if (needsTrgm) {
-    statements.push("CREATE EXTENSION IF NOT EXISTS pg_trgm");
-  }
-  statements.push(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
-  for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
-  }
-  statements.push(...emitJournalDDL(schemaName));
-  if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
-    statements.push(...emitFactoryDDL(schemaName));
-  }
-  for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    statements.push(...emitForeignKeyDDL(schemaName, tableName, tableDef));
-  }
-  const hashInput = JSON.stringify({
-    name: def.name,
-    schema: def.schema,
-    sources: def.sources
-  }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
-  const hash = createHash("sha256").update(hashInput).digest("hex");
-  return { statements, hash };
-}
 // src/schema/deployer.ts
-import { sql } from "kysely";
 function toJsonSafe(obj) {
   return JSON.parse(JSON.stringify(obj, (_key, value) => typeof value === "bigint" ? value.toString() : value));
 }
@@ -649,13 +562,12 @@ async function deploySchema(db, def, handlerPath, opts) {
   const ddlDb = db;
   const existing = await getSubgraph(db, def.name, opts?.accountId);
   const schemaName = opts?.schemaName ?? pgSchemaName(def.name);
-  const newVersion = opts?.version ?? (existing ? bumpPatch(existing.version) : "1.0.0");
+  const newVersion = existing ? bumpPatch(existing.version) : "1.0.0";
   const regData = {
     name: def.name,
     version: newVersion,
     definition: toJsonSafe({
       name: def.name,
-      version: def.version,
       description: def.description,
       startBlock: def.startBlock,
       sources: def.sources,
@@ -681,8 +593,8 @@ async function deploySchema(db, def, handlerPath, opts) {
       for (const stmt of statements) {
         await sql.raw(stmt).execute(ddlDb);
       }
-      const sg2 = await registerSubgraph(db, regData);
-      return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
+      const sg = await registerSubgraph(db, regData);
+      return { action: "reindexed", subgraphId: sg.id, version: newVersion };
     }
     if (existing.schema_hash === hash && !opts?.forceReindex) {
       const handlerChanged = opts?.handlerCode != null && opts.handlerCode !== existing.handler_code;
@@ -707,8 +619,8 @@ async function deploySchema(db, def, handlerPath, opts) {
       for (const stmt of statements) {
         await sql.raw(stmt).execute(ddlDb);
       }
-      const sg2 = await registerSubgraph(db, regData);
-      return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
+      const sg = await registerSubgraph(db, regData);
+      return { action: "reindexed", subgraphId: sg.id, version: newVersion };
     }
     if (existing.definition.schema) {
       const diff = diffSchema(existing.definition.schema, def.schema);
@@ -718,13 +630,13 @@ async function deploySchema(db, def, handlerPath, opts) {
         for (const stmt of statements) {
           await sql.raw(stmt).execute(ddlDb);
         }
-        const sg3 = await registerSubgraph(db, regData);
-        const deployDiff2 = toDeployDiff(diff, reasons);
+        const sg = await registerSubgraph(db, regData);
+        const deployDiff = toDeployDiff(diff, reasons);
         return {
           action: "reindexed",
-          subgraphId: sg3.id,
+          subgraphId: sg.id,
           version: newVersion,
-          diff: deployDiff2
+          diff: deployDiff
         };
       }
       const addedDefs = diff.addedTables.map((tableName) => ({ tableName, tableDef: def.schema[tableName] })).filter((t) => t.tableDef !== undefined);
@@ -736,11 +648,6 @@ async function deploySchema(db, def, handlerPath, opts) {
           await sql.raw(stmt).execute(ddlDb);
         }
       }
-      for (const { tableName, tableDef } of addedDefs) {
-        for (const stmt of emitForeignKeyDDL(schemaName, tableName, tableDef)) {
-          await sql.raw(stmt).execute(ddlDb);
-        }
-      }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
         if (colDiff.added.length === 0)
           continue;
@@ -830,7 +737,7 @@ async function deploySchema(db, def, handlerPath, opts) {
           await sql.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
         }
       }
-      const sg2 = await registerSubgraph(db, regData);
+      const sg = await registerSubgraph(db, regData);
       const addedCols = {};
       for (const [t, colDiff] of Object.entries(diff.tables)) {
         if (colDiff.added.length > 0)
@@ -846,7 +753,7 @@ async function deploySchema(db, def, handlerPath, opts) {
       };
       return {
         action: "updated",
-        subgraphId: sg2.id,
+        subgraphId: sg.id,
         version: newVersion,
         diff: deployDiff
       };
@@ -877,11 +784,11 @@ function getDefault(type) {
   }
 }
 export {
-  generateSubgraphSQL,
-  diffSchema,
+  TYPE_MAP,
   deploySchema,
-  TYPE_MAP
+  diffSchema,
+  generateSubgraphSQL
 };
 
-//# debugId=796006DC2864C80064756E2164756E21
+//# debugId=054E6A0FD91586DA64756E2164756E21
 //# sourceMappingURL=index.js.map