@secondlayer/subgraphs 3.19.10 → 3.20.0

package/dist/src/index.d.ts

@@ -411,7 +411,16 @@ type AggregateResult<
 	max: Record<ColsOf<A, "max">, string | null>
 } : unknown);
 interface SubgraphTableClient<TRow> {
-	findMany(options?: FindManyOptions<TRow>): Promise<TRow[]>;
+	/**
+	* List rows. `fields` narrows BOTH the wire payload and the return type:
+	* the server projects the SELECT to exactly those columns, so an
+	* unrequested field is physically absent — reading it is a compile error,
+	* not `undefined`. The `const` type parameter keeps the literal field
+	* names without `as const` at the call site (same pattern as `aggregate`).
+	*/
+	findMany<const F extends readonly (keyof TRow & string)[] = readonly (keyof TRow & string)[]>(options?: Omit<FindManyOptions<TRow>, "fields"> & {
+		fields?: F
+	}): Promise<Pick<TRow, F[number]>[]>;
 	count(where?: WhereInput<TRow> & SystemWhereAliases): Promise<number>;
 	/**
 	* Scalar aggregates over the filtered set. SUM/MIN/MAX accept numeric columns
@@ -793,19 +802,41 @@ interface TableDiff {
 	removedTables: string[];
 	/** Per-table column diffs (only for tables present in both) */
 	tables: Record<string, ColumnDiff>;
+	/** Per-table uniqueKeys / composite-index diffs (tables present in both) */
+	constraints: Record<string, ConstraintDiff>;
 }
 interface ColumnDiff {
 	added: string[];
 	removed: string[];
+	/** Data-shape changes (type/nullable/default) — breaking. */
 	changed: string[];
+	/** Only the `indexed`/`search` flags differ — index DDL, never a rebuild. */
+	indexChanged: string[];
+}
+interface ConstraintDiff {
+	/** New uniqueKeys entries → `ALTER TABLE … ADD CONSTRAINT` (additive). */
+	addedUniqueKeys: string[][];
+	/** Removed uniqueKeys entries — breaking: handler upserts may target them. */
+	removedUniqueKeys: string[][];
+	/** New composite `indexes` entries → CREATE INDEX (additive). */
+	addedIndexes: string[][];
+	/** Removed composite `indexes` entries → DROP INDEX (additive). */
+	removedIndexes: string[][];
 }
 /**
 * Compare two multi-table subgraph schemas and return differences.
+*
+* Index-only changes (`indexed`/`search` flags, composite `indexes`) are
+* reported separately from data-shape changes: an index never requires a
+* rebuild, so it must never land in `changed`/breaking — flipping
+* `indexed: true` on a populated column used to cost a full reindex.
 */
 declare function diffSchema(existing: SubgraphSchema, incoming: SubgraphSchema): TableDiff;
 /**
 * Returns true if the diff contains any breaking changes
-* (removed tables, removed columns, or changed column types).
+* (removed tables, removed columns, changed column types, or removed
+* uniqueKeys — handler upserts `ON CONFLICT` against those).
+* Index-flag and composite-index changes are never breaking.
 */
 declare function hasBreakingChanges(diff: TableDiff): {
 	breaking: boolean
@@ -816,6 +847,10 @@ interface DeployDiff {
 	removedTables: string[];
 	addedColumns: Record<string, string[]>;
 	breakingChanges: string[];
+	/** Columns whose only change was the `indexed`/`search` flag (index DDL applied in place). */
+	indexChanges?: Record<string, string[]>;
+	/** uniqueKeys added in place via ALTER TABLE … ADD CONSTRAINT. */
+	addedUniqueKeys?: Record<string, string[][]>;
 }
 interface ByoMigrationPlan {
 	schemaName: string;
@@ -877,6 +912,8 @@ declare function deploySchema(db: AnyDb, def: SubgraphDefinition, handlerPath: s
 	subgraphId: string
 	version: string
 	diff?: DeployDiff
+	/** Non-fatal caveats the caller should surface (e.g. handler grafts at tip). */
+	warnings?: string[]
 }>;
 /** A (decoded event type, optional contract scope) pair the sparse probe
 *  checks. Contract scoping is what makes token-subgraph reindexes leap over

package/dist/src/index.js

@@ -3843,31 +3843,53 @@ import { sql as sql4 } from "kysely";
 function toJsonSafe(obj) {
   return JSON.parse(JSON.stringify(obj, (_key, value) => typeof value === "bigint" ? value.toString() : value));
 }
+function columnDataShape(col) {
+  const { indexed, search, ...rest } = col ?? {};
+  return JSON.stringify(rest, Object.keys(rest).sort());
+}
+function diffKeyLists(existing, incoming) {
+  const key2 = (cols) => JSON.stringify(cols);
+  const existingSet = new Set((existing ?? []).map(key2));
+  const incomingSet = new Set((incoming ?? []).map(key2));
+  return {
+    added: (incoming ?? []).filter((cols) => !existingSet.has(key2(cols))),
+    removed: (existing ?? []).filter((cols) => !incomingSet.has(key2(cols)))
+  };
+}
 function diffSchema(existing, incoming) {
   const existingTables = new Set(Object.keys(existing));
   const incomingTables = new Set(Object.keys(incoming));
   const addedTables = [...incomingTables].filter((t) => !existingTables.has(t));
   const removedTables = [...existingTables].filter((t) => !incomingTables.has(t));
   const tables = {};
+  const constraints = {};
   for (const tableName of incomingTables) {
     if (!existingTables.has(tableName))
       continue;
-    const existingCols = existing[tableName]?.columns;
-    const incomingCols = incoming[tableName]?.columns;
+    const existingTable = existing[tableName];
+    const incomingTable = incoming[tableName];
+    const existingCols = existingTable?.columns;
+    const incomingCols = incomingTable?.columns;
     const existingKeys = new Set(Object.keys(existingCols));
     const incomingKeys = new Set(Object.keys(incomingCols));
+    const common = [...incomingKeys].filter((k) => existingKeys.has(k));
+    const sortedStringify = (o) => JSON.stringify(o, Object.keys(o).sort());
     tables[tableName] = {
       added: [...incomingKeys].filter((k) => !existingKeys.has(k)),
       removed: [...existingKeys].filter((k) => !incomingKeys.has(k)),
-      changed: [...incomingKeys].filter((k) => {
-        if (!existingKeys.has(k))
-          return false;
-        const sortedStringify = (o) => JSON.stringify(o, Object.keys(o).sort());
-        return sortedStringify(existingCols[k]) !== sortedStringify(incomingCols[k]);
-      })
+      changed: common.filter((k) => columnDataShape(existingCols[k]) !== columnDataShape(incomingCols[k])),
+      indexChanged: common.filter((k) => columnDataShape(existingCols[k]) === columnDataShape(incomingCols[k]) && sortedStringify(existingCols[k]) !== sortedStringify(incomingCols[k]))
+    };
+    const uq = diffKeyLists(existingTable?.uniqueKeys, incomingTable?.uniqueKeys);
+    const ix = diffKeyLists(existingTable?.indexes, incomingTable?.indexes);
+    constraints[tableName] = {
+      addedUniqueKeys: uq.added,
+      removedUniqueKeys: uq.removed,
+      addedIndexes: ix.added,
+      removedIndexes: ix.removed
     };
   }
-  return { addedTables, removedTables, tables };
+  return { addedTables, removedTables, tables, constraints };
 }
 function hasBreakingChanges(diff) {
   const reasons = [];
@@ -3882,6 +3904,11 @@ function hasBreakingChanges(diff) {
       reasons.push(`${table}: changed columns [${colDiff.changed.join(", ")}]`);
     }
   }
+  for (const [table, conDiff] of Object.entries(diff.constraints ?? {})) {
+    if (conDiff.removedUniqueKeys.length > 0) {
+      reasons.push(`${table}: removed uniqueKeys [${conDiff.removedUniqueKeys.map((cols) => `(${cols.join(", ")})`).join(", ")}]`);
+    }
+  }
   return { breaking: reasons.length > 0, reasons };
 }
 function bumpPatch(version) {
@@ -3987,7 +4014,12 @@ async function deploySchema(db, def, handlerPath, opts) {
       return {
         action: handlerChanged ? "handler_updated" : "unchanged",
         subgraphId: existing.id,
-        version: existing.version
+        version: existing.version,
+        ...handlerChanged ? {
+          warnings: [
+            "handler changed but schema did not: new logic applies from the current tip only. Rows already indexed were computed by the previous handler. To recompute history, redeploy with --reindex (or backfill a range)."
+          ]
+        } : {}
       };
     }
     if (existing.schema_hash === hash && opts?.forceReindex) {
@@ -4058,6 +4090,65 @@ async function deploySchema(db, def, handlerPath, opts) {
           }
         }
       }
+      const existingSchema = existing.definition.schema;
+      const flagFlips = {};
+      const needsTrgmForFlips = Object.entries(diff.tables).some(([tableName, colDiff]) => colDiff.indexChanged.some((colName) => def.schema[tableName]?.columns[colName]?.search && !existingSchema[tableName]?.columns[colName]?.search));
+      if (needsTrgmForFlips) {
+        await sql4.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+      }
+      for (const [tableName, colDiff] of Object.entries(diff.tables)) {
+        if (colDiff.indexChanged.length === 0)
+          continue;
+        flagFlips[tableName] = colDiff.indexChanged;
+        const qualifiedName = `${schemaName}.${tableName}`;
+        for (const colName of colDiff.indexChanged) {
+          const was = existingSchema[tableName]?.columns[colName];
+          const now = def.schema[tableName]?.columns[colName];
+          if (!now)
+            continue;
+          const plainIdx = `idx_${schemaName}_${tableName}_${colName}`;
+          const trgmIdx = `idx_${schemaName}_${tableName}_${colName}_trgm`;
+          if (now.indexed && !was?.indexed) {
+            await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${plainIdx} ON ${qualifiedName} (${colName})`).execute(ddlDb);
+          } else if (!now.indexed && was?.indexed) {
+            await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${plainIdx}`).execute(ddlDb);
+          }
+          if (now.search && !was?.search) {
+            await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${trgmIdx} ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+          } else if (!now.search && was?.search) {
+            await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
+          }
+        }
+      }
+      const addedUq = {};
+      for (const [tableName, conDiff] of Object.entries(diff.constraints)) {
+        const qualifiedName = `${schemaName}.${tableName}`;
+        for (const cols of conDiff.addedUniqueKeys) {
+          const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
+          const exists = await sql4`
+						SELECT EXISTS (
+							SELECT 1 FROM pg_constraint
+							WHERE conname = ${constraintName}
+						) AS "exists"
+					`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
+          if (!exists) {
+            await sql4.raw(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`).execute(ddlDb);
+          }
+          addedUq[tableName] = [...addedUq[tableName] ?? [], cols];
+        }
+        for (const cols of conDiff.addedIndexes) {
+          const i = (def.schema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
+          const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+          await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`).execute(ddlDb);
+        }
+        for (const cols of conDiff.removedIndexes) {
+          const i = (existingSchema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
+          if (i < 0)
+            continue;
+          const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+          await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
+        }
+      }
       const sg2 = await registerSubgraph(db, regData);
       const addedCols = {};
       for (const [t, colDiff] of Object.entries(diff.tables)) {
@@ -4068,7 +4159,9 @@ async function deploySchema(db, def, handlerPath, opts) {
         addedTables: diff.addedTables,
         removedTables: [],
         addedColumns: addedCols,
-        breakingChanges: []
+        breakingChanges: [],
+        ...Object.keys(flagFlips).length > 0 ? { indexChanges: flagFlips } : {},
+        ...Object.keys(addedUq).length > 0 ? { addedUniqueKeys: addedUq } : {}
       };
       return {
         action: "updated",
@@ -4126,5 +4219,5 @@ export {
   ByoBreakingChangeError
 };
 
-//# debugId=9D76C8C8FCA229DB64756E2164756E21
+//# debugId=E040C325764492FC64756E2164756E21
 //# sourceMappingURL=index.js.map