@secondlayer/subgraphs 2.0.8 → 3.0.0

package/dist/src/index.d.ts

@@ -246,11 +246,249 @@ declare function backfillSubgraph(def: SubgraphDefinition, opts: {
 }): Promise<{
 	processed: number
 }>;
+interface FtTransferPayload {
+	sender: string;
+	recipient: string;
+	amount: bigint;
+	assetIdentifier: string;
+	tx: TxMeta;
+}
+interface FtMintPayload {
+	recipient: string;
+	amount: bigint;
+	assetIdentifier: string;
+	tx: TxMeta;
+}
+interface FtBurnPayload {
+	sender: string;
+	amount: bigint;
+	assetIdentifier: string;
+	tx: TxMeta;
+}
+interface NftTransferPayload {
+	sender: string;
+	recipient: string;
+	tokenId: unknown;
+	assetIdentifier: string;
+	tx: TxMeta;
+}
+interface NftMintPayload {
+	recipient: string;
+	tokenId: unknown;
+	assetIdentifier: string;
+	tx: TxMeta;
+}
+interface NftBurnPayload {
+	sender: string;
+	tokenId: unknown;
+	assetIdentifier: string;
+	tx: TxMeta;
+}
+interface StxTransferPayload {
+	sender: string;
+	recipient: string;
+	amount: bigint;
+	/** Memo string, or "" when none was attached. */
+	memo: string;
+	tx: TxMeta;
+}
+interface StxMintPayload {
+	recipient: string;
+	amount: bigint;
+	tx: TxMeta;
+}
+interface StxBurnPayload {
+	sender: string;
+	amount: bigint;
+	tx: TxMeta;
+}
+interface StxLockPayload {
+	lockedAddress: string;
+	lockedAmount: bigint;
+	unlockHeight: bigint;
+	tx: TxMeta;
+}
+interface PrintEventPayload {
+	contractId: string;
+	/** Decoded print topic (the Clarity tuple's `topic` field), or "". */
+	topic: string;
+	/**
+	* Remaining decoded tuple fields, camelCased. Empty object when the print
+	* value isn't a tuple. Narrow per `topic` to access typed fields.
+	*/
+	data: Record<string, unknown>;
+	tx: TxMeta;
+}
+interface ContractDeployPayload {
+	contractId: string;
+	deployer: string;
+	tx: TxMeta;
+}
+/** The event payload a handler receives for a given source filter. */
+type EventForFilter<F extends SubgraphFilter> = F extends {
+	type: "print_event"
+} ? PrintEventPayload : F extends {
+	type: "ft_transfer"
+} ? FtTransferPayload : F extends {
+	type: "ft_mint"
+} ? FtMintPayload : F extends {
+	type: "ft_burn"
+} ? FtBurnPayload : F extends {
+	type: "nft_transfer"
+} ? NftTransferPayload : F extends {
+	type: "nft_mint"
+} ? NftMintPayload : F extends {
+	type: "nft_burn"
+} ? NftBurnPayload : F extends {
+	type: "stx_transfer"
+} ? StxTransferPayload : F extends {
+	type: "stx_mint"
+} ? StxMintPayload : F extends {
+	type: "stx_burn"
+} ? StxBurnPayload : F extends {
+	type: "stx_lock"
+} ? StxLockPayload : F extends {
+	type: "contract_call"
+} ? ContractCallEvent : F extends {
+	type: "contract_deploy"
+} ? ContractDeployPayload : never;
+/** Union of every event payload — the `"*"` catch-all handler receives this. */
+type AnyEvent = FtTransferPayload | FtMintPayload | FtBurnPayload | NftTransferPayload | NftMintPayload | NftBurnPayload | StxTransferPayload | StxMintPayload | StxBurnPayload | StxLockPayload | PrintEventPayload | ContractCallEvent | ContractDeployPayload;
+/** Maps a ColumnType string literal to its TypeScript equivalent */
+type ColumnToTS<T extends string> = T extends "uint" | "int" ? bigint : T extends "text" | "principal" | "timestamp" ? string : T extends "boolean" ? boolean : T extends "jsonb" ? Record<string, unknown> : unknown;
+/** Infer TS type for a single column definition, respecting nullable */
+type InferColumnType<C extends SubgraphColumn> = C["type"] extends ColumnType ? C["nullable"] extends true ? ColumnToTS<C["type"]> | null : ColumnToTS<C["type"]> : unknown;
+/** Shape of system columns on every returned row (camelCase, underscore-prefixed) */
+interface SystemRow {
+	_id: string;
+	_blockHeight: bigint;
+	_txId: string;
+	_createdAt: string;
+}
+/** Infer the row shape for a single table definition */
+type InferTableRow<T extends SubgraphTable> = SystemRow & { [K in keyof T["columns"]] : InferColumnType<T["columns"][K]> };
+/** Comparison operators for a scalar value */
+type ComparisonFilter<T> = {
+	eq?: T
+	neq?: T
+	gt?: T
+	gte?: T
+	lt?: T
+	lte?: T
+};
+/** Where clause — each column accepts a scalar (eq) or comparison object */
+type WhereInput<TRow> = { [K in keyof TRow]? : TRow[K] | ComparisonFilter<TRow[K]> };
 /**
-* Identity function that preserves schema literal types for type inference.
+* No-prefix aliases for system columns accepted in where/orderBy inputs.
+* Both `_blockHeight` and `blockHeight` are valid — serializer handles mapping.
+*/
+type SystemWhereAliases = {
+	blockHeight?: bigint | ComparisonFilter<bigint>
+	txId?: string | ComparisonFilter<string>
+	createdAt?: string | ComparisonFilter<string>
+	id?: string | ComparisonFilter<string>
+};
+type SystemOrderByAliases = {
+	blockHeight?: "asc" | "desc"
+	txId?: "asc" | "desc"
+	createdAt?: "asc" | "desc"
+	id?: "asc" | "desc"
+};
+interface FindManyOptions<TRow> {
+	where?: WhereInput<TRow> & SystemWhereAliases;
+	orderBy?: { [K in keyof TRow]? : "asc" | "desc" } & SystemOrderByAliases;
+	limit?: number;
+	offset?: number;
+	fields?: (keyof TRow & string)[];
+}
+interface SubgraphTableClient<TRow> {
+	findMany(options?: FindManyOptions<TRow>): Promise<TRow[]>;
+	count(where?: WhereInput<TRow> & SystemWhereAliases): Promise<number>;
+}
+/** A column is optional on insert when it's nullable or has a SQL default. */
+type IsOptionalColumn<C> = C extends {
+	nullable: true
+} ? true : C extends {
+	default: string | number | boolean
+} ? true : false;
+/**
+* Row shape accepted by `ctx.insert`. System columns (`_id`, `_blockHeight`,
+* `_txId`, `_createdAt`) are omitted — the runtime adds them. Nullable and
+* defaulted columns are optional; all others required.
+*/
+type WriteRow<T extends SubgraphTable> = { [K in keyof T["columns"] as IsOptionalColumn<T["columns"][K]> extends true ? never : K] : InferColumnType<T["columns"][K]> } & { [K in keyof T["columns"] as IsOptionalColumn<T["columns"][K]> extends true ? K : never]? : InferColumnType<T["columns"][K]> };
+/** Computed-or-value row for `patchOrInsert` — each field may be a function of the existing row. */
+type PatchRow<T extends SubgraphTable> = { [K in keyof WriteRow<T>]? : WriteRow<T>[K] | ((existing: InferTableRow<T> | null) => unknown) };
+type TableName<S extends SubgraphSchema> = keyof S & string;
+type ColumnName<
+	S extends SubgraphSchema,
+	T extends TableName<S>
+> = keyof S[T]["columns"] & string;
+type RowWhere<
+	S extends SubgraphSchema,
+	T extends TableName<S>
+> = WhereInput<InferTableRow<S[T]>>;
+/**
+* Schema-typed handler context. Mirrors the runtime `SubgraphContext` but
+* checks table names against `S` and row/where shapes against each table's
+* columns. The runtime passes the concrete (untyped) context — this facade is
+* type-level only.
+*/
+interface TypedSubgraphContext<S extends SubgraphSchema> {
+	block: {
+		height: number
+		hash: string
+		timestamp: number
+		burnBlockHeight: number
+	};
+	tx: TxMeta;
+	insert<T extends TableName<S>>(table: T, row: WriteRow<S[T]>): void;
+	update<T extends TableName<S>>(table: T, where: RowWhere<S, T>, set: Partial<WriteRow<S[T]>>): void;
+	upsert<T extends TableName<S>>(table: T, key: Partial<WriteRow<S[T]>>, row: WriteRow<S[T]>): void;
+	delete<T extends TableName<S>>(table: T, where: RowWhere<S, T>): void;
+	patch<T extends TableName<S>>(table: T, where: RowWhere<S, T>, set: Partial<WriteRow<S[T]>>): void;
+	patchOrInsert<T extends TableName<S>>(table: T, key: Partial<WriteRow<S[T]>>, row: PatchRow<S[T]> & Record<string, ComputedValue>): Promise<void>;
+	findOne<T extends TableName<S>>(table: T, where: RowWhere<S, T>): Promise<InferTableRow<S[T]> | null>;
+	findMany<T extends TableName<S>>(table: T, where: RowWhere<S, T>): Promise<InferTableRow<S[T]>[]>;
+	formatUnits(value: bigint, decimals: number): string;
+	count<T extends TableName<S>>(table: T, where?: RowWhere<S, T>): Promise<number>;
+	sum<T extends TableName<S>>(table: T, column: ColumnName<S, T>, where?: RowWhere<S, T>): Promise<bigint>;
+	min<T extends TableName<S>>(table: T, column: ColumnName<S, T>, where?: RowWhere<S, T>): Promise<bigint | null>;
+	max<T extends TableName<S>>(table: T, column: ColumnName<S, T>, where?: RowWhere<S, T>): Promise<bigint | null>;
+	countDistinct<T extends TableName<S>>(table: T, column: ColumnName<S, T>, where?: RowWhere<S, T>): Promise<number>;
+}
+/** Infer a typed client object from a subgraph definition shape */
+type InferSubgraphClient<T> = T extends {
+	schema: infer S
+} ? { [K in keyof S] : S[K] extends SubgraphTable ? SubgraphTableClient<InferTableRow<S[K]>> : never } : never;
+/**
+* Handlers keyed by source name. Each handler's `event` is typed from the
+* matching source's filter `type` (e.g. a `print_event` source → `event.topic`
+* is a `string`), and `ctx` is typed against the subgraph `schema` (table
+* names + row columns checked). The optional `"*"` catch-all receives any event.
 *
-* The generic `S` is narrowed to the exact schema shape so that column type
-* literals (e.g. `"uint"`) are preserved rather than widened to `string`.
+* Handlers are optional per source (a source with no handler is skipped at
+* runtime), matching `handlers[name] ?? handlers["*"]` resolution.
+*/
+type TypedHandlers<
+	Sources extends Record<string, SubgraphFilter>,
+	S extends SubgraphSchema
+> = { [K in keyof Sources]? : (event: EventForFilter<Sources[K]>, ctx: TypedSubgraphContext<S>) => void | Promise<void> } & {
+	"*"?: (event: AnyEvent, ctx: TypedSubgraphContext<S>) => void | Promise<void>
+};
+/** Subgraph definition with `sources`/`schema` literals preserved for typed
+* handlers and downstream query-client inference (`getSubgraph`). */
+type TypedSubgraphDefinition<
+	Sources extends Record<string, SubgraphFilter>,
+	S extends SubgraphSchema
+> = Omit<SubgraphDefinition, "sources" | "schema" | "handlers"> & {
+	sources: Sources
+	schema: S
+	handlers: TypedHandlers<Sources, S>
+};
+/**
+* Identity function that preserves `sources` and `schema` literal types so
+* handlers are typed per source and the schema drives query-client inference.
 *
 * @example
 * ```ts
@@ -258,15 +496,19 @@ declare function backfillSubgraph(def: SubgraphDefinition, opts: {
 *   name: "my-subgraph",
 *   sources: { transfer: { type: "ft_transfer", assetIdentifier: "SP...::token" } },
 *   schema: { transfers: { columns: { amount: { type: "uint" } } } },
-*   handlers: { transfer: (event, ctx) => { ... } }
-* })
+*   handlers: {
+*     transfer: (event, ctx) => {
+*       // event: FtTransferPayload → event.amount is bigint, no cast
+*       ctx.insert("transfers", { amount: event.amount });
+*     },
+*   },
+* });
 * ```
 */
-declare function defineSubgraph<S extends SubgraphSchema>(def: Omit<SubgraphDefinition, "schema"> & {
-	schema: S
-}): Omit<SubgraphDefinition, "schema"> & {
-	schema: S
-};
+declare function defineSubgraph<
+	const Sources extends Record<string, SubgraphFilter>,
+	const S extends SubgraphSchema
+>(def: TypedSubgraphDefinition<Sources, S>): TypedSubgraphDefinition<Sources, S>;
 interface GeneratedSQL {
 	statements: string[];
 	hash: string;
@@ -325,59 +567,4 @@ declare function deploySchema(db: AnyDb, def: SubgraphDefinition, handlerPath: s
 	version: string
 	diff?: DeployDiff
 }>;
-/** Maps a ColumnType string literal to its TypeScript equivalent */
-type ColumnToTS<T extends string> = T extends "uint" | "int" ? bigint : T extends "text" | "principal" | "timestamp" ? string : T extends "boolean" ? boolean : T extends "jsonb" ? Record<string, unknown> : unknown;
-/** Infer TS type for a single column definition, respecting nullable */
-type InferColumnType<C extends SubgraphColumn> = C["type"] extends ColumnType ? C["nullable"] extends true ? ColumnToTS<C["type"]> | null : ColumnToTS<C["type"]> : unknown;
-/** Shape of system columns on every returned row (camelCase, underscore-prefixed) */
-interface SystemRow {
-	_id: string;
-	_blockHeight: bigint;
-	_txId: string;
-	_createdAt: string;
-}
-/** Infer the row shape for a single table definition */
-type InferTableRow<T extends SubgraphTable> = SystemRow & { [K in keyof T["columns"]] : InferColumnType<T["columns"][K]> };
-/** Comparison operators for a scalar value */
-type ComparisonFilter<T> = {
-	eq?: T
-	neq?: T
-	gt?: T
-	gte?: T
-	lt?: T
-	lte?: T
-};
-/** Where clause — each column accepts a scalar (eq) or comparison object */
-type WhereInput<TRow> = { [K in keyof TRow]? : TRow[K] | ComparisonFilter<TRow[K]> };
-/**
-* No-prefix aliases for system columns accepted in where/orderBy inputs.
-* Both `_blockHeight` and `blockHeight` are valid — serializer handles mapping.
-*/
-type SystemWhereAliases = {
-	blockHeight?: bigint | ComparisonFilter<bigint>
-	txId?: string | ComparisonFilter<string>
-	createdAt?: string | ComparisonFilter<string>
-	id?: string | ComparisonFilter<string>
-};
-type SystemOrderByAliases = {
-	blockHeight?: "asc" | "desc"
-	txId?: "asc" | "desc"
-	createdAt?: "asc" | "desc"
-	id?: "asc" | "desc"
-};
-interface FindManyOptions<TRow> {
-	where?: WhereInput<TRow> & SystemWhereAliases;
-	orderBy?: { [K in keyof TRow]? : "asc" | "desc" } & SystemOrderByAliases;
-	limit?: number;
-	offset?: number;
-	fields?: (keyof TRow & string)[];
-}
-interface SubgraphTableClient<TRow> {
-	findMany(options?: FindManyOptions<TRow>): Promise<TRow[]>;
-	count(where?: WhereInput<TRow> & SystemWhereAliases): Promise<number>;
-}
-/** Infer a typed client object from a subgraph definition shape */
-type InferSubgraphClient<T> = T extends {
-	schema: infer S
-} ? { [K in keyof S] : S[K] extends SubgraphTable ? SubgraphTableClient<InferTableRow<S[K]>> : never } : never;
-export { validateSubgraphDefinition, resumeReindex, reindexSubgraph, pgSchemaName, generateSubgraphSQL, diffSchema, deploySchema, defineSubgraph, backfillSubgraph, WhereInput, TxMeta, TableDiff, SystemRow, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferFilter, StxMintFilter, StxLockFilter, StxBurnFilter, RowValue, ReindexOptions, PrintEventFilter, NftTransferFilter, NftMintFilter, NftBurnFilter, InferTableRow, InferSubgraphClient, InferColumnType, GeneratedSQL, FtTransferFilter, FtMintFilter, FtBurnFilter, FindManyOptions, ContractDeployFilter, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff };
+export { validateSubgraphDefinition, resumeReindex, reindexSubgraph, pgSchemaName, generateSubgraphSQL, diffSchema, deploySchema, defineSubgraph, backfillSubgraph, WriteRow, WhereInput, TypedSubgraphDefinition, TypedSubgraphContext, TypedHandlers, TxMeta, TableDiff, SystemRow, SubgraphTableClient, SubgraphTable, SubgraphSchema, SubgraphHandler, SubgraphFilter, SubgraphDefinition, SubgraphContext, SubgraphColumn, StxTransferPayload, StxTransferFilter, StxMintPayload, StxMintFilter, StxLockPayload, StxLockFilter, StxBurnPayload, StxBurnFilter, RowValue, ReindexOptions, PrintEventPayload, PrintEventFilter, NftTransferPayload, NftTransferFilter, NftMintPayload, NftMintFilter, NftBurnPayload, NftBurnFilter, InferTableRow, InferSubgraphClient, InferColumnType, GeneratedSQL, FtTransferPayload, FtTransferFilter, FtMintPayload, FtMintFilter, FtBurnPayload, FtBurnFilter, FindManyOptions, EventForFilter, ContractDeployPayload, ContractDeployFilter, ContractCallFilter, ContractCallEvent, ComputedValue, ComparisonFilter, ColumnType, ColumnToTS, ColumnDiff, AnyEvent };

package/dist/src/index.js

@@ -1387,6 +1387,7 @@ import {
 import { logger as logger5 } from "@secondlayer/shared/logger";
 
 // src/schema/generator.ts
+import { createHash as createHash2 } from "node:crypto";
 var TYPE_MAP = {
   text: "TEXT",
   uint: "NUMERIC",
@@ -1466,7 +1467,7 @@ function generateSubgraphSQL(def, schemaNameOverride) {
     schema: def.schema,
     sources: def.sources
   }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
-  const hash = String(Bun.hash(hashInput));
+  const hash = createHash2("sha256").update(hashInput).digest("hex");
   return { statements, hash };
 }
 
@@ -2175,5 +2176,5 @@ export {
   backfillSubgraph
 };
 
-//# debugId=76698A606CE0E66264756E2164756E21
+//# debugId=E831E58EC98F118E64756E2164756E21
 //# sourceMappingURL=index.js.map