@secondlayer/subgraphs 3.2.1 → 3.4.0

package/dist/src/index.js

@@ -23,7 +23,13 @@ var SubgraphColumnSchema = z.object({
 var SubgraphTableSchema = z.object({
   columns: z.record(z.string(), SubgraphColumnSchema).refine((c) => Object.keys(c).length > 0, "Table must have at least one column"),
   indexes: z.array(z.array(z.string())).optional(),
-  uniqueKeys: z.array(z.array(z.string())).optional()
+  uniqueKeys: z.array(z.array(z.string())).optional(),
+  relations: z.array(z.object({
+    name: z.string(),
+    references: z.string(),
+    fields: z.array(z.string()).min(1),
+    referencedColumns: z.array(z.string()).min(1)
+  })).optional()
 });
 var SubgraphSchemaSchema = z.record(z.string(), SubgraphTableSchema).refine((s) => Object.keys(s).length > 0, "Schema must have at least one table");
 var VALID_FILTER_TYPES = [
@@ -55,7 +61,8 @@ var SubgraphFilterSchema = z.object({
   contractName: z.string().optional(),
   topic: z.string().optional(),
   lockedAddress: z.string().optional(),
-  abi: z.record(z.string(), z.any()).optional()
+  abi: z.record(z.string(), z.any()).optional(),
+  trait: z.string().optional()
 }).strict();
 var SubgraphDefinitionSchema = z.object({
   name: SubgraphNameSchema,
@@ -87,12 +94,14 @@ class SubgraphContext {
   pgSchemaName;
   subgraphSchema;
   ops = [];
-  constructor(db, pgSchemaName, subgraphSchema, block, tx) {
+  byo;
+  constructor(db, pgSchemaName, subgraphSchema, block, tx, byo = false) {
     this.db = db;
     this.pgSchemaName = pgSchemaName;
     this.subgraphSchema = subgraphSchema;
     this.block = block;
     this._tx = tx;
+    this.byo = byo;
   }
   get tx() {
     return this._tx;
@@ -287,6 +296,15 @@ class SubgraphContext {
   }
   buildStatements(ops) {
     const statements = [];
+    if (this.byo) {
+      const insertTables = new Set;
+      for (const op of ops)
+        if (op.kind === "insert")
+          insertTables.add(op.table);
+      for (const table of insertTables) {
+        statements.push(`DELETE FROM "${this.pgSchemaName}"."${table}" WHERE "_block_height" = ${this.block.height}`);
+      }
+    }
     let currentBatch = null;
     let currentBatchKey = "";
     const flushInsertBatch = () => {
@@ -780,7 +798,19 @@ function matchPattern(value, pattern) {
   }
   return re.test(value);
 }
-function matchFilter(filter, transactions, eventsByTx) {
+var EMPTY_SET = new Set;
+function traitAllows(filter, contractId, traitContracts) {
+  const trait = filter.trait;
+  if (!trait)
+    return true;
+  if (!contractId)
+    return false;
+  return (traitContracts.get(trait) ?? EMPTY_SET).has(contractId);
+}
+function assetContract(assetId) {
+  return assetId?.split("::")[0];
+}
+function matchFilter(filter, transactions, eventsByTx, traitContracts) {
   const results = [];
   switch (filter.type) {
     case "stx_transfer":
@@ -844,6 +874,8 @@ function matchFilter(filter, transactions, eventsByTx) {
             if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
               return false;
           }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
           if ("sender" in filter && filter.sender) {
             if (!matchPattern(data.sender, filter.sender))
               return false;
@@ -882,6 +914,8 @@ function matchFilter(filter, transactions, eventsByTx) {
             if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
               return false;
           }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
           if ("sender" in filter && filter.sender) {
             if (!matchPattern(data.sender, filter.sender))
               return false;
@@ -914,6 +948,8 @@ function matchFilter(filter, transactions, eventsByTx) {
           if (!matchPattern(tx.sender, filter.caller))
             continue;
         }
+        if (!traitAllows(filter, tx.contract_id, traitContracts))
+          continue;
         const txEvents = eventsByTx.get(tx.tx_id) ?? [];
         results.push({ tx, events: txEvents });
       }
@@ -948,11 +984,13 @@ function matchFilter(filter, transactions, eventsByTx) {
             return false;
           if (data.topic !== "print")
             return false;
+          const printContractId = data.contract_identifier ?? data.contract_id;
           if (filter.contractId) {
-            const contractId = data.contract_identifier ?? data.contract_id;
-            if (!contractId || !matchPattern(contractId, filter.contractId))
+            if (!printContractId || !matchPattern(printContractId, filter.contractId))
               return false;
           }
+          if (!traitAllows(filter, printContractId, traitContracts))
+            return false;
           return true;
         });
         if (matched.length > 0) {
@@ -964,7 +1002,7 @@ function matchFilter(filter, transactions, eventsByTx) {
   }
   return results;
 }
-function matchSources(sources, transactions, events) {
+function matchSources(sources, transactions, events, traitContracts = new Map) {
   const eventsByTx = new Map;
   for (const event of events) {
     const list = eventsByTx.get(event.tx_id) ?? [];
@@ -974,7 +1012,7 @@ function matchSources(sources, transactions, events) {
   const seen = new Set;
   const results = [];
   for (const [sourceName, filter] of Object.entries(sources)) {
-    const matches = matchFilter(filter, transactions, eventsByTx);
+    const matches = matchFilter(filter, transactions, eventsByTx, traitContracts);
     for (const match of matches) {
       const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
       if (!seen.has(dedupeKey)) {
@@ -991,8 +1029,11 @@ import {
   getSourceDb,
   getTargetDb
 } from "@secondlayer/shared/db";
+import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
 import {
+  isByoSubgraph,
   recordSubgraphProcessed,
+  resolveSubgraphDb,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
 import { logger as logger4 } from "@secondlayer/shared/logger";
@@ -1230,7 +1271,38 @@ async function refreshMatcher(db) {
 }
 
 // src/runtime/block-processor.ts
-var schemaNameCache = new Map;
+var routeCache = new Map;
+async function resolveRoute(subgraphName, targetDb) {
+  const cached = routeCache.get(subgraphName);
+  if (cached)
+    return cached;
+  const row = await targetDb.selectFrom("subgraphs").selectAll().where("name", "=", subgraphName).executeTakeFirst();
+  const byo = row ? isByoSubgraph(row) : false;
+  const route = {
+    schemaName: row?.schema_name ?? pgSchemaName(subgraphName),
+    dataDb: row && byo ? resolveSubgraphDb(row) : targetDb,
+    byo
+  };
+  routeCache.set(subgraphName, route);
+  return route;
+}
+function invalidateSubgraphRoute(subgraphName) {
+  routeCache.delete(subgraphName);
+}
+async function resolveTraitContracts(subgraph, blockHeight, db) {
+  const traits = new Set;
+  for (const source of Object.values(subgraph.sources)) {
+    const trait = source.trait;
+    if (trait)
+      traits.add(trait);
+  }
+  const resolved = new Map;
+  for (const trait of traits) {
+    const ids = await resolveTraitContractIds(db, trait, blockHeight);
+    resolved.set(trait, new Set(ids));
+  }
+  return resolved;
+}
 async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   const sourceDb = getSourceDb();
   const targetDb = getTargetDb();
@@ -1270,7 +1342,8 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     txs = await sourceDb.selectFrom("transactions").selectAll().where("block_height", "=", blockHeight).execute();
     evts = await sourceDb.selectFrom("events").selectAll().where("block_height", "=", blockHeight).execute();
   }
-  const matched = matchSources(subgraph.sources, txs, evts);
+  const traitContracts = await resolveTraitContracts(subgraph, blockHeight, targetDb);
+  const matched = matchSources(subgraph.sources, txs, evts, traitContracts);
   result.matched = matched.length;
   if (matched.length === 0) {
     if (!opts?.skipProgressUpdate) {
@@ -1278,12 +1351,8 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     }
     return result;
   }
-  let schemaName = schemaNameCache.get(subgraphName);
-  if (!schemaName) {
-    const subgraphRecord = await targetDb.selectFrom("subgraphs").select("schema_name").where("name", "=", subgraphName).executeTakeFirst();
-    schemaName = subgraphRecord?.schema_name ?? pgSchemaName(subgraphName);
-    schemaNameCache.set(subgraphName, schemaName);
-  }
+  const route = await resolveRoute(subgraphName, targetDb);
+  const schemaName = route.schemaName;
   const blockMeta = {
     height: block.height,
     hash: block.hash,
@@ -1298,30 +1367,57 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   };
   let handlerMs = 0;
   let flushMs = 0;
-  await targetDb.transaction().execute(async (tx) => {
-    const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx);
-    const handlerStart = performance.now();
-    const runResult = await runHandlers(subgraph, matched, ctx);
-    handlerMs = performance.now() - handlerStart;
+  const applyProgress = async (tx, rr) => {
+    if (opts?.skipProgressUpdate)
+      return;
+    const status = rr.errors > 0 && rr.processed === 0 ? "error" : "active";
+    await updateSubgraphStatus(tx, subgraphName, status, blockHeight);
+    if (rr.processed > 0 || rr.errors > 0) {
+      const lastError = rr.errors > 0 ? `${rr.errors} error(s) at block ${blockHeight}` : undefined;
+      await recordSubgraphProcessed(tx, subgraphName, rr.processed, rr.errors, lastError);
+    }
+  };
+  if (route.byo) {
+    let runResult = { processed: 0, errors: 0 };
+    let manifest;
+    await route.dataDb.transaction().execute(async (tx) => {
+      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, true);
+      const handlerStart = performance.now();
+      runResult = await runHandlers(subgraph, matched, ctx);
+      handlerMs = performance.now() - handlerStart;
+      if (ctx.pendingOps > 0) {
+        const flushStart = performance.now();
+        manifest = await ctx.flush();
+        flushMs = performance.now() - flushStart;
+      }
+    });
     result.processed = runResult.processed;
     result.errors = runResult.errors;
-    if (ctx.pendingOps > 0) {
-      const flushStart = performance.now();
-      const manifest = await ctx.flush();
-      if (manifest.count > 0) {
+    await targetDb.transaction().execute(async (tx) => {
+      if (manifest && manifest.count > 0) {
         await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
       }
-      flushMs = performance.now() - flushStart;
-    }
-    if (!opts?.skipProgressUpdate) {
-      const status = runResult.errors > 0 && runResult.processed === 0 ? "error" : "active";
-      await updateSubgraphStatus(tx, subgraphName, status, blockHeight);
-    }
-    if (!opts?.skipProgressUpdate && (runResult.processed > 0 || runResult.errors > 0)) {
-      const lastError = runResult.errors > 0 ? `${runResult.errors} error(s) at block ${blockHeight}` : undefined;
-      await recordSubgraphProcessed(tx, subgraphName, runResult.processed, runResult.errors, lastError);
-    }
-  });
+      await applyProgress(tx, runResult);
+    });
+  } else {
+    await targetDb.transaction().execute(async (tx) => {
+      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx);
+      const handlerStart = performance.now();
+      const runResult = await runHandlers(subgraph, matched, ctx);
+      handlerMs = performance.now() - handlerStart;
+      result.processed = runResult.processed;
+      result.errors = runResult.errors;
+      if (ctx.pendingOps > 0) {
+        const flushStart = performance.now();
+        const manifest = await ctx.flush();
+        if (manifest.count > 0) {
+          await emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, block.height);
+        }
+        flushMs = performance.now() - flushStart;
+      }
+      await applyProgress(tx, runResult);
+    });
+  }
   const totalMs = performance.now() - blockStart;
   result.timing = {
     totalMs: Math.round(totalMs),
@@ -1332,7 +1428,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     try {
       const tables = Object.keys(subgraph.schema);
       for (const table of tables) {
-        const { rows } = await sql3.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(targetDb);
+        const { rows } = await sql3.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(route.dataDb);
         const count = Number(rows[0]?.count ?? 0);
         if (count >= 1e7) {
           logger4.warn("Subgraph table exceeds 10M rows (estimate)", {
@@ -1504,6 +1600,12 @@ function generateSubgraphSQL(def, schemaNameOverride) {
       }
     }
   }
+  for (const [tableName, tableDef] of Object.entries(def.schema)) {
+    for (const rel of tableDef.relations ?? []) {
+      const constraintName = `fk_${schemaName}_${tableName}_${rel.name}`;
+      statements.push(`ALTER TABLE ${schemaName}.${tableName} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.join(", ")}) ` + `REFERENCES ${schemaName}.${rel.references} (${rel.referencedColumns.join(", ")})`);
+    }
+  }
   const hashInput = JSON.stringify({
     name: def.name,
     schema: def.schema,
@@ -1968,6 +2070,283 @@ async function backfillSubgraph(def, opts) {
 function defineSubgraph(def) {
   return def;
 }
+// src/schema/prisma.ts
+var PRISMA_TYPE = {
+  uint: { type: "Decimal", db: "@db.Numeric" },
+  int: { type: "Decimal", db: "@db.Numeric" },
+  text: { type: "String" },
+  principal: { type: "String" },
+  boolean: { type: "Boolean" },
+  timestamp: { type: "DateTime", db: "@db.Timestamptz" },
+  jsonb: { type: "Json" }
+};
+var SYSTEM_FIELDS = [
+  { field: "id", col: "_id", line: "BigInt   @id @default(autoincrement())" },
+  { field: "blockHeight", col: "_block_height", line: "BigInt" },
+  { field: "txId", col: "_tx_id", line: "String" },
+  {
+    field: "createdAt",
+    col: "_created_at",
+    line: "DateTime @default(now()) @db.Timestamptz"
+  }
+];
+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);
+}
+function quotePrismaDefault(value) {
+  if (typeof value === "string")
+    return `@default("${value.replace(/"/g, "\\\"")}")`;
+  return `@default(${value})`;
+}
+function renderTable(tableName, table, backRelations) {
+  const lines = [];
+  for (const sys of SYSTEM_FIELDS) {
+    lines.push(`  ${sys.field} ${sys.line} @map("${sys.col}")`);
+  }
+  for (const [colName, col] of Object.entries(table.columns)) {
+    const field = snakeToCamel(colName);
+    const mapped = PRISMA_TYPE[col.type];
+    const optional = col.nullable ? "?" : "";
+    const attrs = [];
+    if (field !== colName)
+      attrs.push(`@map("${colName}")`);
+    if (col.default !== undefined)
+      attrs.push(quotePrismaDefault(col.default));
+    if (mapped.db)
+      attrs.push(mapped.db);
+    lines.push(`  ${field} ${mapped.type}${optional}${attrs.length ? ` ${attrs.join(" ")}` : ""}`);
+  }
+  for (const rel of table.relations ?? []) {
+    const optional = rel.fields.some((f) => table.columns[f]?.nullable) ? "?" : "";
+    const relName = `${pascalCase(tableName)}_${rel.name}`;
+    const fields = rel.fields.map(snakeToCamel).join(", ");
+    const refs = rel.referencedColumns.map(snakeToCamel).join(", ");
+    lines.push(`  ${rel.name} ${pascalCase(rel.references)}${optional} @relation("${relName}", fields: [${fields}], references: [${refs}])`);
+  }
+  for (const back of backRelations) {
+    lines.push(`  ${back.field} ${back.model}[] @relation("${back.relationName}")`);
+  }
+  const block = [];
+  for (const [colName, col] of Object.entries(table.columns)) {
+    if (col.indexed)
+      block.push(`  @@index([${snakeToCamel(colName)}])`);
+  }
+  for (const cols of table.indexes ?? []) {
+    block.push(`  @@index([${cols.map(snakeToCamel).join(", ")}])`);
+  }
+  for (const cols of table.uniqueKeys ?? []) {
+    block.push(`  @@unique([${cols.map(snakeToCamel).join(", ")}])`);
+  }
+  block.push(`  @@map("${tableName}")`);
+  return `model ${pascalCase(tableName)} {
+${lines.join(`
+`)}
+
+${block.join(`
+`)}
+}`;
+}
+function computeBackRelations(schema) {
+  const map = new Map;
+  for (const [owningTable, table] of Object.entries(schema)) {
+    for (const rel of table.relations ?? []) {
+      const list = map.get(rel.references) ?? [];
+      list.push({
+        field: `${snakeToCamel(owningTable)}${pascalCase(rel.name)}`,
+        model: pascalCase(owningTable),
+        relationName: `${pascalCase(owningTable)}_${rel.name}`
+      });
+      map.set(rel.references, list);
+    }
+  }
+  return map;
+}
+function generatePrismaSchema(def, opts = {}) {
+  const schemaName = opts.schemaName ?? pgSchemaName(def.name);
+  const env = opts.datasourceEnv ?? "DATABASE_URL";
+  const header = [
+    `// Generated by \`sl generate prisma\` from subgraph "${def.name}". Do not edit by hand.`,
+    "",
+    "datasource db {",
+    '  provider = "postgresql"',
+    `  url      = env("${env}")`,
+    `  schemas  = ["${schemaName}"]`,
+    "}",
+    "",
+    "generator client {",
+    '  provider        = "prisma-client-js"',
+    '  previewFeatures = ["multiSchema"]',
+    "}"
+  ].join(`
+`);
+  const backRelations = computeBackRelations(def.schema);
+  const modelBlocks = Object.entries(def.schema).map(([tableName, table]) => {
+    const body = renderTable(tableName, table, backRelations.get(tableName) ?? []);
+    return body.replace(/\n}$/, `
+  @@schema("${schemaName}")
+}`);
+  });
+  if (opts.modelsOnly)
+    return `${modelBlocks.join(`
+
+`)}
+`;
+  return `${header}
+
+${modelBlocks.join(`
+
+`)}
+`;
+}
+// src/schema/drizzle.ts
+var DRIZZLE_BUILDER = {
+  uint: (c) => `numeric("${c}")`,
+  int: (c) => `numeric("${c}")`,
+  text: (c) => `text("${c}")`,
+  principal: (c) => `text("${c}")`,
+  boolean: (c) => `boolean("${c}")`,
+  timestamp: (c) => `timestamp("${c}", { withTimezone: true })`,
+  jsonb: (c) => `jsonb("${c}")`
+};
+var BUILDERS_USED = {
+  uint: "numeric",
+  int: "numeric",
+  text: "text",
+  principal: "text",
+  boolean: "boolean",
+  timestamp: "timestamp",
+  jsonb: "jsonb"
+};
+function snakeToCamel2(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascalCase2(name) {
+  const camel = snakeToCamel2(name);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function literalDefault(value) {
+  return typeof value === "string" ? `"${value.replace(/"/g, "\\\"")}"` : `${value}`;
+}
+function renderTable2(varName, tableName, table) {
+  const cols = [
+    `  id: bigserial("_id", { mode: "bigint" }).primaryKey(),`,
+    `  blockHeight: bigint("_block_height", { mode: "bigint" }).notNull(),`,
+    `  txId: text("_tx_id").notNull(),`,
+    `  createdAt: timestamp("_created_at", { withTimezone: true }).notNull().defaultNow(),`
+  ];
+  for (const [colName, col] of Object.entries(table.columns)) {
+    let line = `  ${snakeToCamel2(colName)}: ${DRIZZLE_BUILDER[col.type](colName)}`;
+    if (!col.nullable)
+      line += ".notNull()";
+    if (col.default !== undefined)
+      line += `.default(${literalDefault(col.default)})`;
+    cols.push(`${line},`);
+  }
+  const extras = [];
+  for (const [colName, col] of Object.entries(table.columns)) {
+    if (col.indexed) {
+      const f = snakeToCamel2(colName);
+      extras.push(`    ${f}Idx: index("idx_${tableName}_${colName}").on(t.${f})`);
+    }
+  }
+  table.indexes?.forEach((idxCols, i) => {
+    const on = idxCols.map((c) => `t.${snakeToCamel2(c)}`).join(", ");
+    extras.push(`    idx${i}: index("idx_${tableName}_${i}").on(${on})`);
+  });
+  table.uniqueKeys?.forEach((uqCols, i) => {
+    const on = uqCols.map((c) => `t.${snakeToCamel2(c)}`).join(", ");
+    extras.push(`    uq${i}: uniqueIndex("uq_${tableName}_${i}").on(${on})`);
+  });
+  const extrasBlock = extras.length ? `, (t) => ({
+${extras.join(`,
+`)},
+  })` : "";
+  return `export const ${varName} = sg.table("${tableName}", {
+${cols.join(`
+`)}
+}${extrasBlock});`;
+}
+function renderRelations(schema) {
+  const back = new Map;
+  for (const [owning, table] of Object.entries(schema)) {
+    for (const rel of table.relations ?? []) {
+      const list = back.get(rel.references) ?? [];
+      list.push({
+        field: `${snakeToCamel2(owning)}${pascalCase2(rel.name)}`,
+        from: snakeToCamel2(owning)
+      });
+      back.set(rel.references, list);
+    }
+  }
+  const out = [];
+  for (const [tableName, table] of Object.entries(schema)) {
+    const v = snakeToCamel2(tableName);
+    const ones = (table.relations ?? []).map((rel) => {
+      const localFields = rel.fields.map((f) => `${v}.${snakeToCamel2(f)}`).join(", ");
+      const refFields = rel.referencedColumns.map((c) => `${snakeToCamel2(rel.references)}.${snakeToCamel2(c)}`).join(", ");
+      return `  ${rel.name}: one(${snakeToCamel2(rel.references)}, { fields: [${localFields}], references: [${refFields}] }),`;
+    });
+    const manys = (back.get(tableName) ?? []).map((b) => `  ${b.field}: many(${b.from}),`);
+    if (ones.length === 0 && manys.length === 0)
+      continue;
+    const helpers = [ones.length ? "one" : "", manys.length ? "many" : ""].filter(Boolean).join(", ");
+    out.push(`export const ${v}Relations = relations(${v}, ({ ${helpers} }) => ({
+${[...ones, ...manys].join(`
+`)}
+}));`);
+  }
+  return out;
+}
+function generateDrizzleSchema(def, opts = {}) {
+  const schemaName = opts.schemaName ?? pgSchemaName(def.name);
+  const used = new Set(["bigserial", "bigint", "text", "timestamp"]);
+  let needsIndex = false;
+  let needsUnique = false;
+  for (const table of Object.values(def.schema)) {
+    for (const col of Object.values(table.columns))
+      used.add(BUILDERS_USED[col.type]);
+    if (Object.values(table.columns).some((c) => c.indexed) || table.indexes?.length)
+      needsIndex = true;
+    if (table.uniqueKeys?.length)
+      needsUnique = true;
+  }
+  if (needsIndex)
+    used.add("index");
+  if (needsUnique)
+    used.add("uniqueIndex");
+  used.add("pgSchema");
+  const hasRelations = Object.values(def.schema).some((t) => t.relations?.length);
+  const imports = [
+    `import { ${[...used].sort().join(", ")} } from "drizzle-orm/pg-core";`,
+    ...hasRelations ? [`import { relations } from "drizzle-orm";`] : []
+  ].join(`
+`);
+  const tables = Object.entries(def.schema).map(([name, table]) => renderTable2(snakeToCamel2(name), name, table));
+  const relationDecls = renderRelations(def.schema);
+  const typeExports = Object.keys(def.schema).map((name) => `export type ${pascalCase2(name)} = typeof ${snakeToCamel2(name)}.$inferSelect;`);
+  return [
+    `// Generated by \`sl generate drizzle\` from subgraph "${def.name}". Do not edit by hand.`,
+    imports,
+    "",
+    `export const sg = pgSchema("${schemaName}");`,
+    "",
+    tables.join(`
+
+`),
+    ...relationDecls.length ? ["", relationDecls.join(`
+
+`)] : [],
+    "",
+    typeExports.join(`
+`),
+    ""
+  ].join(`
+`);
+}
 // src/schema/deployer.ts
 import { sql as sql4 } from "kysely";
 function toJsonSafe(obj) {
@@ -2021,10 +2400,29 @@ function bumpPatch(version) {
   const patch = Number.parseInt(parts[2] ?? "0", 10);
   return `${parts[0]}.${parts[1]}.${Number.isNaN(patch) ? 1 : patch + 1}`;
 }
+function renderDeployPlan(def, schemaName) {
+  validateSubgraphDefinition(def);
+  const { statements } = generateSubgraphSQL(def, schemaName);
+  const schema = schemaName ?? pgSchemaName(def.name);
+  const grantScript = [
+    "-- Run once on YOUR database as an owner/superuser, replacing <role>",
+    "-- with the role whose credentials you give Secondlayer.",
+    "-- Secondlayer then creates and owns only this one schema:",
+    `GRANT CREATE ON DATABASE current_database() TO <role>;`,
+    `-- (after first deploy <role> owns "${schema}"; no further grants needed)`
+  ].join(`
+`);
+  return { schemaName: schema, statements, grantScript };
+}
 async function deploySchema(db, def, handlerPath, opts) {
   validateSubgraphDefinition(def);
   const { statements, hash } = generateSubgraphSQL(def, opts?.schemaName);
   const { getSubgraph, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
+  const ddlDb = opts?.dataDb ?? db;
+  const byo = opts?.dataDb != null;
+  const refuseDestructiveOnByo = (reason) => {
+    throw new Error(`Breaking schema change on a BYO subgraph (${reason}) would drop data in your database. Drop the schema "${opts?.schemaName ?? pgSchemaName(def.name)}" manually and re-deploy to rebuild.`);
+  };
   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");
@@ -2046,7 +2444,8 @@ async function deploySchema(db, def, handlerPath, opts) {
     handlerCode: opts?.handlerCode,
     sourceCode: opts?.sourceCode,
     schemaName,
-    startBlock: def.startBlock
+    startBlock: def.startBlock,
+    databaseUrlEnc: opts?.databaseUrlEnc ?? null
   };
   if (existing) {
     const schemaExists = await sql4`
@@ -2054,10 +2453,10 @@ async function deploySchema(db, def, handlerPath, opts) {
 				SELECT 1 FROM information_schema.schemata
 				WHERE schema_name = ${schemaName}
 			) AS "exists"
-		`.execute(db).then((r) => r.rows[0]?.exists ?? false);
+		`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
     if (!schemaExists) {
       for (const stmt of statements) {
-        await sql4.raw(stmt).execute(db);
+        await sql4.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -2076,9 +2475,11 @@ async function deploySchema(db, def, handlerPath, opts) {
       };
     }
     if (existing.schema_hash === hash && opts?.forceReindex) {
-      await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(db);
+      if (byo)
+        refuseDestructiveOnByo("force reindex");
+      await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
       for (const stmt of statements) {
-        await sql4.raw(stmt).execute(db);
+        await sql4.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -2087,9 +2488,12 @@ async function deploySchema(db, def, handlerPath, opts) {
       const diff = diffSchema(existing.definition.schema, def.schema);
       const { breaking, reasons } = hasBreakingChanges(diff);
       if (breaking || opts?.forceReindex) {
-        await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(db);
+        if (byo) {
+          refuseDestructiveOnByo(reasons.length > 0 ? reasons.join("; ") : "force reindex");
+        }
+        await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
         for (const stmt of statements) {
-          await sql4.raw(stmt).execute(db);
+          await sql4.raw(stmt).execute(ddlDb);
         }
         const sg3 = await registerSubgraph(db, regData);
         const deployDiff2 = {
@@ -2126,15 +2530,15 @@ async function deploySchema(db, def, handlerPath, opts) {
         await sql4.raw(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
   ${colDefs.join(`,
   `)}
-)`).execute(db);
-        await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`).execute(db);
-        await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`).execute(db);
+)`).execute(ddlDb);
+        await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`).execute(ddlDb);
+        await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`).execute(ddlDb);
         for (const [colName, col] of Object.entries(tableDef.columns)) {
           if (col.indexed) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(db);
+            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           }
           if (col.search) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(db);
+            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
           }
         }
       }
@@ -2153,12 +2557,12 @@ async function deploySchema(db, def, handlerPath, opts) {
           if (!sqlType)
             continue;
           const nullable = col.nullable ? "" : ` NOT NULL DEFAULT ${getDefault(col.type)}`;
-          await sql4.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(db);
+          await sql4.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
           if (col.indexed) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(db);
+            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           }
           if (col.search) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(db);
+            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
           }
         }
       }
@@ -2183,7 +2587,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     }
   }
   for (const stmt of statements) {
-    await sql4.raw(stmt).execute(db);
+    await sql4.raw(stmt).execute(ddlDb);
   }
   const sg = await registerSubgraph(db, regData);
   return { action: "created", subgraphId: sg.id, version: newVersion };
@@ -2209,14 +2613,17 @@ function getDefault(type) {
 export {
   validateSubgraphDefinition,
   resumeReindex,
+  renderDeployPlan,
   reindexSubgraph,
   pgSchemaName,
   generateSubgraphSQL,
+  generatePrismaSchema,
+  generateDrizzleSchema,
   diffSchema,
   deploySchema,
   defineSubgraph,
   backfillSubgraph
 };
 
-//# debugId=E652DFA8BE73568E64756E2164756E21
+//# debugId=12416214D391B0FF64756E2164756E21
 //# sourceMappingURL=index.js.map