@secondlayer/subgraphs 3.7.3 → 3.8.0

package/dist/src/index.d.ts

@@ -628,6 +628,35 @@ interface DrizzleGenOptions {
 	schemaName?: string;
 }
 declare function generateDrizzleSchema(def: SubgraphDefinition, opts?: DrizzleGenOptions): string;
+interface KyselyGenOptions {
+	/** Postgres schema the tables live in (account-scoped). */
+	schemaName?: string;
+}
+declare function generateKyselySchema(def: SubgraphDefinition, opts?: KyselyGenOptions): string;
+/**
+* Emit a portable, typed schema for the public Index read domain (blocks,
+* decoded events, transactions, stacking, sBTC, BNS, …) from the single-sourced
+* `SOURCE_READ_TYPES` registry. This is the Index arm of the "typed Stacks data in
+* your own stack" story: a BYO-database consumer mirrors Index rows and gets a
+* fully-typed ORM / JSON-Schema that can't drift from the API (the registry is
+* drift-tested against the producer's read contract).
+*
+* Prisma uses the `SOURCE_READ_PKS` registry for model identity. Tables whose only
+* physical PK is a synthetic id excluded from the read contract (chain_reorgs) have
+* no read-set key and are omitted from Prisma output (other targets still emit them).
+*/
+type IndexCodegenTarget = "prisma" | "kysely" | "drizzle" | "json-schema";
+interface IndexCodegenOptions {
+	/** Restrict output to these Index tables (default: all). */
+	tables?: string[];
+	/** Postgres schema to qualify table names with (default: bare names). */
+	schemaName?: string;
+	/** Prisma only: datasource url env var (default DATABASE_URL). */
+	datasourceEnv?: string;
+}
+declare function generateIndexSchema(target: IndexCodegenTarget, opts?: IndexCodegenOptions): string;
+/** Index tables available to codegen, for help text and validation. */
+declare const INDEX_CODEGEN_TABLES: readonly string[];
 import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
 import { Database } from "@secondlayer/shared/db";
 import { Kysely } from "kysely";
@@ -696,4 +725,4 @@ declare function deploySchema(db: AnyDb, def: SubgraphDefinition, handlerPath: s
 	version: string
 	diff?: DeployDiff
 }>;
-export { validateSubgraphDefinition, resumeReindex, renderDeployPlan, reindexSubgraph, pgSchemaName, generateSubgraphSQL, generatePrismaSchema, generateDrizzleSchema, diffSchema, deploySchema, defineSubgraph, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, RowValue, ReindexOptions, PrismaGenOptions, PrintEventPayload, PrintEventFor, PrintEventFilter, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, InferTableRow, InferSubgraphClient, InferColumnType, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, EventForFilter, DrizzleGenOptions, DeployPlan, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, AnyEvent };
+export { validateSubgraphDefinition, resumeReindex, renderDeployPlan, reindexSubgraph, pgSchemaName, generateSubgraphSQL, generatePrismaSchema, generateKyselySchema, generateIndexSchema, generateDrizzleSchema, diffSchema, deploySchema, defineSubgraph, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubscribeOptions, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, RowValue, ReindexOptions, PrismaGenOptions, PrintEventPayload, PrintEventFor, PrintEventFilter, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, KyselyGenOptions, InferTableRow, InferSubgraphClient, InferColumnType, IndexCodegenTarget, IndexCodegenOptions, INDEX_CODEGEN_TABLES, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, EventForFilter, DrizzleGenOptions, DeployPlan, ContractDeployPayload, ContractDeployFilter, ContractCallPayload, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, AnyEvent };

package/dist/src/index.js

@@ -1293,6 +1293,37 @@ class PublicApiBlockSource {
     return map;
   }
 }
+
+class FallbackBlockSource {
+  primary;
+  fallback;
+  constructor(primary, fallback) {
+    this.primary = primary;
+    this.fallback = fallback;
+  }
+  async getTip() {
+    try {
+      return await this.primary.getTip();
+    } catch (err) {
+      logger3.warn("block source primary getTip failed — using DB tap", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return this.fallback.getTip();
+    }
+  }
+  async loadBlockRange(fromHeight, toHeight) {
+    try {
+      return await this.primary.loadBlockRange(fromHeight, toHeight);
+    } catch (err) {
+      logger3.warn("block source primary loadBlockRange failed — using DB tap", {
+        from: fromHeight,
+        to: toHeight,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return this.fallback.loadBlockRange(fromHeight, toHeight);
+    }
+  }
+}
 var postgresBlockSource = new PostgresBlockSource;
 function buildHttpClient() {
   const baseUrl = process.env.SUBGRAPH_INDEX_API_URL ?? process.env.STREAMS_API_URL ?? "http://api:3800";
@@ -1304,7 +1335,7 @@ function buildHttpClient() {
 }
 function resolveBlockSource(subgraph) {
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph && isStreamsIndexEligible(subgraph)) {
-    return new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph));
+    return new FallbackBlockSource(new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph)), postgresBlockSource);
   }
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph) {
     logger3.debug("Subgraph not streams-index eligible, using DB tap", {
@@ -1813,67 +1844,78 @@ function escapeLiteralDefault(value) {
     return value ? "TRUE" : "FALSE";
   return `'${String(value).replace(/'/g, "''")}'`;
 }
-function generateSubgraphSQL(def, schemaNameOverride) {
-  const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
+function tableNeedsTrgm(tableDef) {
+  return Object.values(tableDef.columns).some((col) => col.search);
+}
+function emitTableDDL(schemaName, tableName, tableDef) {
+  const qualifiedName = `${schemaName}.${tableName}`;
   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)) {
-    const qualifiedName = `${schemaName}.${tableName}`;
-    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 = `${colName} ${sqlType}${nullable}`;
-      if (col.default !== undefined) {
-        colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
-      }
-      columnDefs.push(colDef);
+  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 = `${colName} ${sqlType}${nullable}`;
+    if (col.default !== undefined) {
+      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
     }
-    statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
+    columnDefs.push(colDef);
+  }
+  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
   ${columnDefs.join(`,
   `)}
 )`);
-    statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`);
-    statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`);
-    for (const [colName, col] of Object.entries(tableDef.columns)) {
-      if (col.indexed) {
-        statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`);
-      }
+  statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`);
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.indexed) {
+      statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`);
     }
-    for (const [colName, col] of Object.entries(tableDef.columns)) {
-      if (col.search) {
-        statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`);
-      }
+  }
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.search) {
+      statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`);
     }
-    if (tableDef.indexes) {
-      for (let i = 0;i < tableDef.indexes.length; i++) {
-        const cols = tableDef.indexes[i];
-        const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
-        statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`);
-      }
+  }
+  if (tableDef.indexes) {
+    for (let i = 0;i < tableDef.indexes.length; i++) {
+      const cols = tableDef.indexes[i];
+      const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`);
     }
-    if (tableDef.uniqueKeys) {
-      for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
-        const cols = tableDef.uniqueKeys[i];
-        const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
-        statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`);
-      }
+  }
+  if (tableDef.uniqueKeys) {
+    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
+      const cols = tableDef.uniqueKeys[i];
+      const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
+      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`);
     }
   }
+  return statements;
+}
+function emitForeignKeyDDL(schemaName, tableName, tableDef) {
+  return (tableDef.relations ?? []).map((rel) => {
+    const constraintName = `fk_${schemaName}_${tableName}_${rel.name}`;
+    return `ALTER TABLE ${schemaName}.${tableName} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.join(", ")}) ` + `REFERENCES ${schemaName}.${rel.references} (${rel.referencedColumns.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)) {
-    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(", ")})`);
-    }
+    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
+  }
+  for (const [tableName, tableDef] of Object.entries(def.schema)) {
+    statements.push(...emitForeignKeyDDL(schemaName, tableName, tableDef));
   }
   const hashInput = JSON.stringify({
     name: def.name,
@@ -2568,6 +2610,304 @@ function generateDrizzleSchema(def, opts = {}) {
   ].join(`
 `);
 }
+// src/schema/kysely.ts
+var KYSELY_TYPE = {
+  uint: "string",
+  int: "string",
+  text: "string",
+  principal: "string",
+  boolean: "boolean",
+  timestamp: "Date",
+  jsonb: "unknown"
+};
+var SYSTEM_FIELDS2 = [
+  { col: "_id", type: "Generated<string>" },
+  { col: "_block_height", type: "string" },
+  { col: "_tx_id", type: "string" },
+  { col: "_created_at", type: "Generated<Date>" }
+];
+function pascalCase3(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function renderTable3(tableName, table) {
+  const lines = SYSTEM_FIELDS2.map((f) => `  ${f.col}: ${f.type};`);
+  for (const [colName, col] of Object.entries(table.columns)) {
+    let type = KYSELY_TYPE[col.type];
+    if (col.nullable)
+      type = `${type} | null`;
+    if (col.default !== undefined)
+      type = `Generated<${type}>`;
+    lines.push(`  ${colName}: ${type};`);
+  }
+  return `export interface ${pascalCase3(tableName)} {
+${lines.join(`
+`)}
+}`;
+}
+function generateKyselySchema(def, opts = {}) {
+  const schemaName = opts.schemaName ?? pgSchemaName(def.name);
+  const interfaces = Object.entries(def.schema).map(([name, table]) => renderTable3(name, table));
+  const dbEntries = Object.keys(def.schema).map((name) => `  "${schemaName}.${name}": ${pascalCase3(name)};`);
+  const dbRegistry = `export interface DB {
+${dbEntries.join(`
+`)}
+}`;
+  const rowExports = Object.keys(def.schema).map((name) => `export type ${pascalCase3(name)}Row = Selectable<${pascalCase3(name)}>;`);
+  return [
+    `// Generated by \`sl subgraphs codegen --target kysely\` from subgraph "${def.name}". Do not edit by hand.`,
+    `import type { Generated, Selectable } from "kysely";`,
+    "",
+    interfaces.join(`
+
+`),
+    "",
+    dbRegistry,
+    "",
+    rowExports.join(`
+`),
+    ""
+  ].join(`
+`);
+}
+// src/schema/index-codegen.ts
+import {
+  SOURCE_READ_PKS,
+  SOURCE_READ_TYPES
+} from "@secondlayer/shared/db";
+function pascalCase4(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
+}
+function snakeToCamel3(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function selectTables(opts) {
+  const all = SOURCE_READ_TYPES;
+  const names = opts.tables ?? Object.keys(all);
+  return names.map((name) => {
+    const cols = all[name];
+    if (!cols) {
+      throw new Error(`Unknown Index table "${name}". Known: ${Object.keys(all).sort().join(", ")}`);
+    }
+    return [name, cols];
+  });
+}
+var KYSELY_TYPE2 = {
+  text: "string",
+  int: "number",
+  boolean: "boolean",
+  timestamp: "Date",
+  jsonb: "unknown"
+};
+function generateKysely(entries, schemaName) {
+  const interfaces = entries.map(([table, cols]) => {
+    const lines = Object.entries(cols).map(([col, def]) => {
+      const type = def.nullable ? `${KYSELY_TYPE2[def.type]} | null` : KYSELY_TYPE2[def.type];
+      return `  ${col}: ${type};`;
+    });
+    return `export interface ${pascalCase4(table)} {
+${lines.join(`
+`)}
+}`;
+  });
+  const dbEntries = entries.map(([table]) => {
+    const key2 = schemaName ? `${schemaName}.${table}` : table;
+    return `  "${key2}": ${pascalCase4(table)};`;
+  });
+  const rows = entries.map(([table]) => `export type ${pascalCase4(table)}Row = Selectable<${pascalCase4(table)}>;`);
+  return [
+    "// Generated by `sl index codegen --target kysely`. Do not edit by hand.",
+    `import type { Selectable } from "kysely";`,
+    "",
+    interfaces.join(`
+
+`),
+    "",
+    `export interface IndexDB {
+${dbEntries.join(`
+`)}
+}`,
+    "",
+    rows.join(`
+`),
+    ""
+  ].join(`
+`);
+}
+var DRIZZLE_BUILDER2 = {
+  text: (c) => `text("${c}")`,
+  int: (c) => `integer("${c}")`,
+  boolean: (c) => `boolean("${c}")`,
+  timestamp: (c) => `timestamp("${c}", { withTimezone: true })`,
+  jsonb: (c) => `jsonb("${c}")`
+};
+var DRIZZLE_BUILDER_NAME = {
+  text: "text",
+  int: "integer",
+  boolean: "boolean",
+  timestamp: "timestamp",
+  jsonb: "jsonb"
+};
+function generateDrizzle(entries, schemaName) {
+  const used = new Set;
+  for (const [, cols] of entries)
+    for (const def of Object.values(cols))
+      used.add(DRIZZLE_BUILDER_NAME[def.type]);
+  if (schemaName)
+    used.add("pgSchema");
+  else
+    used.add("pgTable");
+  const tableFn = schemaName ? "sg.table" : "pgTable";
+  const tables = entries.map(([table, cols]) => {
+    const lines = Object.entries(cols).map(([col, def]) => {
+      let line = `  ${snakeToCamel3(col)}: ${DRIZZLE_BUILDER2[def.type](col)}`;
+      if (!def.nullable)
+        line += ".notNull()";
+      return `${line},`;
+    });
+    return `export const ${snakeToCamel3(table)} = ${tableFn}("${table}", {
+${lines.join(`
+`)}
+});`;
+  });
+  const rows = entries.map(([table]) => `export type ${pascalCase4(table)} = typeof ${snakeToCamel3(table)}.$inferSelect;`);
+  return [
+    "// Generated by `sl index codegen --target drizzle`. Do not edit by hand.",
+    `import { ${[...used].sort().join(", ")} } from "drizzle-orm/pg-core";`,
+    "",
+    ...schemaName ? [`export const sg = pgSchema("${schemaName}");`, ""] : [],
+    tables.join(`
+
+`),
+    "",
+    rows.join(`
+`),
+    ""
+  ].join(`
+`);
+}
+var JSON_SCHEMA_TYPE = {
+  text: { type: "string" },
+  int: { type: "integer" },
+  boolean: { type: "boolean" },
+  timestamp: { type: "string", format: "date-time" },
+  jsonb: {}
+};
+function generateJsonSchema(entries) {
+  const defs = {};
+  for (const [table, cols] of entries) {
+    const properties = {};
+    const required = [];
+    for (const [col, def] of Object.entries(cols)) {
+      const base = JSON_SCHEMA_TYPE[def.type];
+      if (def.nullable && "type" in base) {
+        properties[col] = { ...base, type: [base.type, "null"] };
+      } else {
+        properties[col] = { ...base };
+        if (!def.nullable)
+          required.push(col);
+      }
+    }
+    defs[pascalCase4(table)] = {
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false
+    };
+  }
+  return `${JSON.stringify({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    title: "Secondlayer Index domain",
+    $defs: defs
+  }, null, 2)}
+`;
+}
+var PRISMA_TYPE2 = {
+  text: { type: "String" },
+  int: { type: "Int" },
+  boolean: { type: "Boolean" },
+  timestamp: { type: "DateTime", db: "@db.Timestamptz" },
+  jsonb: { type: "Json" }
+};
+function generatePrisma(entries, schemaName, datasourceEnv) {
+  const pks = SOURCE_READ_PKS;
+  const skipped = [];
+  const models = [];
+  for (const [table, cols] of entries) {
+    const pk = pks[table];
+    if (!pk) {
+      skipped.push(table);
+      continue;
+    }
+    const single = pk.length === 1 ? pk[0] : null;
+    const lines = Object.entries(cols).map(([col, def]) => {
+      const field = snakeToCamel3(col);
+      const mapped = PRISMA_TYPE2[def.type];
+      const attrs = [];
+      if (single === col)
+        attrs.push("@id");
+      if (field !== col)
+        attrs.push(`@map("${col}")`);
+      if (mapped.db)
+        attrs.push(mapped.db);
+      const optional = def.nullable ? "?" : "";
+      return `  ${field} ${mapped.type}${optional}${attrs.length ? ` ${attrs.join(" ")}` : ""}`;
+    });
+    const block = [];
+    if (!single) {
+      block.push(`  @@id([${pk.map(snakeToCamel3).join(", ")}])`);
+    }
+    block.push(`  @@map("${table}")`);
+    if (schemaName)
+      block.push(`  @@schema("${schemaName}")`);
+    models.push(`model ${pascalCase4(table)} {
+${lines.join(`
+`)}
+
+${block.join(`
+`)}
+}`);
+  }
+  const header = [
+    "// Generated by `sl index codegen --target prisma`. Do not edit by hand.",
+    ...skipped.length ? [
+      `// Omitted (no read-set primary key, query via another target): ${skipped.join(", ")}`
+    ] : [],
+    "",
+    "datasource db {",
+    '  provider = "postgresql"',
+    `  url      = env("${datasourceEnv}")`,
+    ...schemaName ? [`  schemas  = ["${schemaName}"]`] : [],
+    "}",
+    "",
+    "generator client {",
+    '  provider        = "prisma-client-js"',
+    ...schemaName ? ['  previewFeatures = ["multiSchema"]'] : [],
+    "}"
+  ].join(`
+`);
+  return `${header}
+
+${models.join(`
+
+`)}
+`;
+}
+function generateIndexSchema(target, opts = {}) {
+  const entries = selectTables(opts);
+  switch (target) {
+    case "prisma":
+      return generatePrisma(entries, opts.schemaName, opts.datasourceEnv ?? "DATABASE_URL");
+    case "kysely":
+      return generateKysely(entries, opts.schemaName);
+    case "drizzle":
+      return generateDrizzle(entries, opts.schemaName);
+    case "json-schema":
+      return generateJsonSchema(entries);
+    default:
+      throw new Error(`Unsupported Index codegen target "${target}".`);
+  }
+}
+var INDEX_CODEGEN_TABLES = Object.keys(SOURCE_READ_TYPES);
 // src/schema/deployer.ts
 import { sql as sql4 } from "kysely";
 function toJsonSafe(obj) {
@@ -2730,37 +3070,18 @@ async function deploySchema(db, def, handlerPath, opts) {
           diff: deployDiff2
         };
       }
-      for (const tableName of diff.addedTables) {
-        const tableDef = def.schema[tableName];
-        if (!tableDef)
-          continue;
-        const qualifiedName = `${schemaName}.${tableName}`;
-        const colDefs = [
-          "_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 nullable = col.nullable ? "" : " NOT NULL";
-          const sqlType = TYPE_MAP[col.type];
-          if (!sqlType)
-            continue;
-          colDefs.push(`${colName} ${sqlType}${nullable}`);
+      const addedDefs = diff.addedTables.map((tableName) => ({ tableName, tableDef: def.schema[tableName] })).filter((t) => t.tableDef !== undefined);
+      if (addedDefs.some(({ tableDef }) => tableNeedsTrgm(tableDef))) {
+        await sql4.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+      }
+      for (const { tableName, tableDef } of addedDefs) {
+        for (const stmt of emitTableDDL(schemaName, tableName, tableDef)) {
+          await sql4.raw(stmt).execute(ddlDb);
         }
-        await sql4.raw(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
-  ${colDefs.join(`,
-  `)}
-)`).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(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(ddlDb);
-          }
+      }
+      for (const { tableName, tableDef } of addedDefs) {
+        for (const stmt of emitForeignKeyDDL(schemaName, tableName, tableDef)) {
+          await sql4.raw(stmt).execute(ddlDb);
         }
       }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
@@ -2839,12 +3160,15 @@ export {
   pgSchemaName,
   generateSubgraphSQL,
   generatePrismaSchema,
+  generateKyselySchema,
+  generateIndexSchema,
   generateDrizzleSchema,
   diffSchema,
   deploySchema,
   defineSubgraph,
-  backfillSubgraph
+  backfillSubgraph,
+  INDEX_CODEGEN_TABLES
 };
 
-//# debugId=403FDFB35EA1452564756E2164756E21
+//# debugId=822BF312943996F964756E2164756E21
 //# sourceMappingURL=index.js.map