@secondlayer/subgraphs 0.11.1 → 0.11.3

package/dist/src/index.js

@@ -102,7 +102,11 @@ class SubgraphContext {
   }
   insert(table, row) {
     this.validateTable(table);
-    this.ops.push({ kind: "insert", table, data: row });
+    this.ops.push({
+      kind: "insert",
+      table,
+      data: { ...row, _block_height: this.block.height, _tx_id: this._tx.txId }
+    });
   }
   update(table, where, set) {
     this.validateTable(table);
@@ -111,13 +115,16 @@ class SubgraphContext {
   upsert(table, key, row) {
     this.validateTable(table);
     const tableDef = this.subgraphSchema[table];
+    if (!tableDef)
+      return;
     const keyColumns = Object.keys(key);
     const hasUniqueConstraint = tableDef.uniqueKeys?.some((uk) => uk.length === keyColumns.length && uk.every((c) => keyColumns.includes(c)));
+    const meta = { _block_height: this.block.height, _tx_id: this._tx.txId };
     if (hasUniqueConstraint) {
       this.ops.push({
         kind: "insert",
         table,
-        data: { ...key, ...row, _upsert_keys: keyColumns }
+        data: { ...key, ...row, ...meta, _upsert_keys: keyColumns }
       });
     } else {
       logger.warn("upsert called without matching uniqueKeys constraint, using fallback", {
@@ -130,6 +137,7 @@ class SubgraphContext {
         data: {
           ...key,
           ...row,
+          ...meta,
           _upsert_fallback_keys: keyColumns,
           _upsert_fallback_set: row
         }
@@ -249,11 +257,13 @@ class SubgraphContext {
   prepareInsert(op) {
     const upsertKeys = op.data._upsert_keys;
     const data = { ...op.data };
-    delete data._upsert_keys;
-    delete data._upsert_fallback_keys;
-    delete data._upsert_fallback_set;
-    data._block_height = this.block.height;
-    data._tx_id = this._tx.txId;
+    data._upsert_keys = undefined;
+    data._upsert_fallback_keys = undefined;
+    data._upsert_fallback_set = undefined;
+    if (!data._block_height)
+      data._block_height = this.block.height;
+    if (!data._tx_id)
+      data._tx_id = this._tx.txId;
     data._created_at = "NOW()";
     const cols = Object.keys(data);
     cols.forEach(validateColumnName);
@@ -268,11 +278,13 @@ class SubgraphContext {
     const flushInsertBatch = () => {
       if (!currentBatch)
         return;
-      const qualifiedTable = `"${this.pgSchemaName}"."${currentBatch.table}"`;
-      const colList = currentBatch.cols.map((c) => `"${c}"`).join(", ");
-      let rows = currentBatch.rows;
-      if (currentBatch.upsertKeys && currentBatch.upsertKeys.length > 0) {
-        const keyIndices = currentBatch.upsertKeys.map((k) => currentBatch.cols.indexOf(k));
+      const batch = currentBatch;
+      const qualifiedTable = `"${this.pgSchemaName}"."${batch.table}"`;
+      const colList = batch.cols.map((c) => `"${c}"`).join(", ");
+      let rows = batch.rows;
+      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
+        const uKeys = batch.upsertKeys;
+        const keyIndices = uKeys.map((k) => batch.cols.indexOf(k));
         const seen = new Map;
         for (let i = 0;i < rows.length; i++) {
           const key = keyIndices.map((ki) => rows[i][ki]).join("\x00");
@@ -284,13 +296,14 @@ class SubgraphContext {
       }
       const valuesList = rows.map((r) => `(${r.join(", ")})`).join(", ");
       let stmt = `INSERT INTO ${qualifiedTable} (${colList}) VALUES ${valuesList}`;
-      if (currentBatch.upsertKeys && currentBatch.upsertKeys.length > 0) {
-        const updateCols = currentBatch.cols.filter((c) => !currentBatch.upsertKeys.includes(c) && !c.startsWith("_"));
+      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
+        const batchKeys = batch.upsertKeys;
+        const updateCols = batch.cols.filter((c) => !batchKeys.includes(c) && !c.startsWith("_"));
         if (updateCols.length > 0) {
           const setClauses = updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`);
-          stmt += ` ON CONFLICT (${currentBatch.upsertKeys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
+          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
         } else {
-          stmt += ` ON CONFLICT (${currentBatch.upsertKeys.map((k) => `"${k}"`).join(", ")}) DO NOTHING`;
+          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO NOTHING`;
         }
       }
       statements.push(stmt);
@@ -311,8 +324,9 @@ class SubgraphContext {
       } else {
         flushInsertBatch();
         if (op.kind === "update") {
-          const setEntries = Object.entries(op.set);
-          setEntries.forEach(([k]) => validateColumnName(k));
+          const setEntries = Object.entries(op.set ?? {});
+          for (const [k] of setEntries)
+            validateColumnName(k);
           const setClauses = setEntries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
           const { clause } = buildWhereClause(op.data);
           statements.push(`UPDATE ${qualifiedTable} SET ${setClauses.join(", ")} WHERE ${clause}`);
@@ -339,14 +353,15 @@ function escapeLiteral(value) {
   if (typeof value === "boolean")
     return value ? "TRUE" : "FALSE";
   if (typeof value === "object")
-    return `'${JSON.stringify(value).replace(/'/g, "''")}'::jsonb`;
+    return `'${JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v).replace(/'/g, "''")}'::jsonb`;
   return `'${String(value).replace(/'/g, "''")}'`;
 }
 function buildWhereClause(where) {
   const entries = Object.entries(where);
   if (entries.length === 0)
     return { clause: "TRUE", values: [] };
-  entries.forEach(([k]) => validateColumnName(k));
+  for (const [k] of entries)
+    validateColumnName(k);
   const parts = entries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
   return { clause: parts.join(" AND "), values: [] };
 }
@@ -1600,7 +1615,8 @@ function diffSchema(existing, incoming) {
       changed: [...incomingKeys].filter((k) => {
         if (!existingKeys.has(k))
           return false;
-        return JSON.stringify(existingCols[k]) !== JSON.stringify(incomingCols[k]);
+        const sortedStringify = (o) => JSON.stringify(o, Object.keys(o).sort());
+        return sortedStringify(existingCols[k]) !== sortedStringify(incomingCols[k]);
       })
     };
   }
@@ -1658,7 +1674,11 @@ async function deploySchema(db, def, handlerPath, opts) {
     if (existing.schema_hash === hash && !opts?.forceReindex) {
       const { updateSubgraphHandlerPath } = await import("@secondlayer/shared/db/queries/subgraphs");
       await updateSubgraphHandlerPath(db, def.name, handlerPath);
-      return { action: "unchanged", subgraphId: existing.id, version: existing.version };
+      return {
+        action: "unchanged",
+        subgraphId: existing.id,
+        version: existing.version
+      };
     }
     if (existing.schema_hash === hash && opts?.forceReindex) {
       await sql3.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(db);
@@ -1683,10 +1703,17 @@ async function deploySchema(db, def, handlerPath, opts) {
           addedColumns: Object.fromEntries(Object.entries(diff.tables).filter(([, c]) => c.added.length > 0).map(([t, c]) => [t, c.added])),
           breakingChanges: reasons
         };
-        return { action: "reindexed", subgraphId: sg3.id, version: newVersion, diff: deployDiff2 };
+        return {
+          action: "reindexed",
+          subgraphId: sg3.id,
+          version: newVersion,
+          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",
@@ -1696,7 +1723,10 @@ async function deploySchema(db, def, handlerPath, opts) {
         ];
         for (const [colName, col] of Object.entries(tableDef.columns)) {
           const nullable = col.nullable ? "" : " NOT NULL";
-          colDefs.push(`${colName} ${TYPE_MAP[col.type]}${nullable}`);
+          const sqlType = TYPE_MAP[col.type];
+          if (!sqlType)
+            continue;
+          colDefs.push(`${colName} ${sqlType}${nullable}`);
         }
         await sql3.raw(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
   ${colDefs.join(`,
@@ -1718,9 +1748,15 @@ async function deploySchema(db, def, handlerPath, opts) {
           continue;
         const qualifiedName = `${schemaName}.${tableName}`;
         const tableDef = def.schema[tableName];
+        if (!tableDef)
+          continue;
         for (const colName of colDiff.added) {
           const col = tableDef.columns[colName];
+          if (!col)
+            continue;
           const sqlType = TYPE_MAP[col.type];
+          if (!sqlType)
+            continue;
           const nullable = col.nullable ? "" : ` NOT NULL DEFAULT ${getDefault(col.type)}`;
           await sql3.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(db);
           if (col.indexed) {
@@ -1743,7 +1779,12 @@ async function deploySchema(db, def, handlerPath, opts) {
         addedColumns: addedCols,
         breakingChanges: []
       };
-      return { action: "updated", subgraphId: sg2.id, version: newVersion, diff: deployDiff };
+      return {
+        action: "updated",
+        subgraphId: sg2.id,
+        version: newVersion,
+        diff: deployDiff
+      };
     }
   }
   for (const stmt of statements) {
@@ -1782,5 +1823,5 @@ export {
   backfillSubgraph
 };
 
-//# debugId=212AA25CD1A71F2B64756E2164756E21
+//# debugId=BDEFBE84CC1D9E3564756E2164756E21
 //# sourceMappingURL=index.js.map