@secondlayer/cli 1.10.0 → 1.10.1

package/dist/cli.js

@@ -20266,7 +20266,7 @@ import { promises as fs3 } from "fs";
 import path from "path";
 import { isValidAddress as _validateStacksAddress } from "@secondlayer/stacks";
 import { getErrorMessage } from "@secondlayer/shared";
-import { toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
 
 class PluginManager {
   plugins = [];
@@ -20490,7 +20490,7 @@ ${JSON.stringify(content, null, 2)}`;
   }
   createUtils() {
     return {
-      toCamelCase: toCamelCase2,
+      toCamelCase: toCamelCase3,
       toKebabCase: (str) => {
         return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
       },
@@ -20541,7 +20541,7 @@ import {
   isAbiStringAscii as isAbiStringAscii2,
   isAbiStringUtf8 as isAbiStringUtf82,
   isAbiTuple,
-  toCamelCase as toCamelCase3
+  toCamelCase as toCamelCase4
 } from "@secondlayer/stacks/clarity";
 function generateClarityConversion(argName, argType) {
   const type = argType.type;
@@ -20632,7 +20632,7 @@ function generateClarityConversion(argName, argType) {
     const requiredFields = type.tuple.map((f) => f.name);
     const fieldNames = JSON.stringify(requiredFields);
     const fields = type.tuple.map((field) => {
-      const camelFieldName = toCamelCase3(field.name);
+      const camelFieldName = toCamelCase4(field.name);
       const fieldConversion = generateClarityConversion(`tupleValue.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -20681,7 +20681,7 @@ import {
   isAbiStringAscii as isAbiStringAscii3,
   isAbiStringUtf8 as isAbiStringUtf83,
   isAbiTuple as isAbiTuple2,
-  toCamelCase as toCamelCase4
+  toCamelCase as toCamelCase5
 } from "@secondlayer/stacks/clarity";
 function clarityTypeToTS(type) {
   if (typeof type === "string") {
@@ -20733,7 +20733,7 @@ function clarityTypeToTS(type) {
     return `${innerType}[]`;
   }
   if (isAbiTuple2(type)) {
-    const fields = type.tuple.map((field) => `${toCamelCase4(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
+    const fields = type.tuple.map((field) => `${toCamelCase5(field.name)}: ${clarityTypeToTS(field.type)}`).join("; ");
     return `{ ${fields} }`;
   }
   if (isAbiResponse2(type)) {
@@ -20751,12 +20751,12 @@ var init_type_mapping = () => {};
 // src/utils/generator-helpers.ts
 import {
   isAbiTuple as isAbiTuple3,
-  toCamelCase as toCamelCase5
+  toCamelCase as toCamelCase6
 } from "@secondlayer/stacks/clarity";
 function generateMapKeyConversion(keyType) {
   if (isAbiTuple3(keyType)) {
     const fields = keyType.tuple.map((field) => {
-      const camelFieldName = toCamelCase5(field.name);
+      const camelFieldName = toCamelCase6(field.name);
       const fieldConversion = generateClarityConversion(`key.${camelFieldName}`, { type: field.type });
       return `"${field.name}": ${fieldConversion}`;
     }).join(", ");
@@ -20771,7 +20771,7 @@ var init_generator_helpers = __esm(() => {
 
 // src/generators/contract.ts
 import {
-  toCamelCase as toCamelCase6
+  toCamelCase as toCamelCase7
 } from "@secondlayer/stacks/clarity";
 function generateNetworkUtils() {
   return `/**
@@ -20863,7 +20863,7 @@ function generateAbiConstant(name, abi) {
   return `export const ${name}Abi = ${abiJson} as const`;
 }
 function generateMethod(func, address, contractName) {
-  const methodName = toCamelCase6(func.name);
+  const methodName = toCamelCase7(func.name);
   if (func.args.length === 0) {
     return `${methodName}() {
     return {
@@ -20876,7 +20876,7 @@ function generateMethod(func, address, contractName) {
   }
   if (func.args.length === 1) {
     const originalArgName = func.args[0].name;
-    const argName = toCamelCase6(originalArgName);
+    const argName = toCamelCase7(originalArgName);
     const argType = getTypeForArg(func.args[0]);
     const clarityConversion = generateClarityConversion(argName, func.args[0]);
     return `${methodName}(...args: [{ ${argName}: ${argType} }] | [${argType}]) {
@@ -20892,17 +20892,17 @@ function generateMethod(func, address, contractName) {
     }
   }`;
   }
-  const argsList = func.args.map((arg) => toCamelCase6(arg.name)).join(", ");
+  const argsList = func.args.map((arg) => toCamelCase7(arg.name)).join(", ");
   const argsTypes = func.args.map((arg) => {
-    const camelName = toCamelCase6(arg.name);
+    const camelName = toCamelCase7(arg.name);
     return `${camelName}: ${getTypeForArg(arg)}`;
   }).join("; ");
   const argsArray = func.args.map((arg) => {
-    const argName = toCamelCase6(arg.name);
+    const argName = toCamelCase7(arg.name);
     return generateClarityConversion(argName, arg);
   }).join(", ");
   const objectAccess = func.args.map((arg) => {
-    const camelName = toCamelCase6(arg.name);
+    const camelName = toCamelCase7(arg.name);
     return `args[0].${camelName}`;
   }).join(", ");
   const positionTypes = func.args.map((arg) => getTypeForArg(arg)).join(", ");
@@ -20924,7 +20924,7 @@ function generateMapsObject(maps, address, contractName) {
     return "";
   }
   const mapMethods = maps.map((map) => {
-    const methodName = toCamelCase6(map.name);
+    const methodName = toCamelCase7(map.name);
     const keyType = getTypeForArg({ type: map.key });
     const valueType = getTypeForArg({ type: map.value });
     const keyConversion = generateMapKeyConversion(map.key);
@@ -20985,7 +20985,7 @@ function generateVarsObject(variables, address, contractName) {
     return "";
   }
   const varMethods = dataVars.map((variable) => {
-    const methodName = toCamelCase6(variable.name);
+    const methodName = toCamelCase7(variable.name);
     const valueType = getTypeForArg({ type: variable.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -21030,7 +21030,7 @@ function generateConstantsObject(variables, address, contractName) {
     return "";
   }
   const constMethods = constants.map((constant) => {
-    const methodName = toCamelCase6(constant.name);
+    const methodName = toCamelCase7(constant.name);
     const valueType = getTypeForArg({ type: constant.type });
     return `${methodName}: {
       async get(options?: { network?: 'mainnet' | 'testnet' | 'devnet' }): Promise<${valueType}> {
@@ -32314,7 +32314,7 @@ __export(exports_generate, {
 });
 import path10 from "path";
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { toCamelCase as toCamelCase7 } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase8 } from "@secondlayer/stacks/clarity";
 function isContractAddress(input4) {
   const contractIdPattern = /^(SP|ST|SM|SN)[A-Z0-9]{38,}\.[a-zA-Z][a-zA-Z0-9-]*$/;
   return contractIdPattern.test(input4);
@@ -32375,7 +32375,7 @@ async function buildConfigFromInputs(parsedInputs, outPath, apiKey, defaultAddre
       const apiClient = new StacksApiClient(network, apiKey);
       const contractInfo = await apiClient.getContractInfo(contractId);
       const abi = parseApiResponse(contractInfo);
-      const name = toCamelCase7(contractName);
+      const name = toCamelCase8(contractName);
       contracts.push({
         name,
         address: contractId,
@@ -32620,7 +32620,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "1.10.0",
+  version: "1.10.1",
   description: "CLI for streams, subgraphs, and real-time blockchain indexing on Stacks",
   type: "module",
   bin: {
@@ -32661,10 +32661,10 @@ var package_default = {
   license: "MIT",
   dependencies: {
     "@inquirer/prompts": "^8.2.0",
-    "@secondlayer/sdk": "^0.9.0",
-    "@secondlayer/shared": "^0.10.0",
+    "@secondlayer/sdk": "^0.9.1",
+    "@secondlayer/shared": "^0.10.1",
     "@secondlayer/stacks": "^0.2.2",
-    "@secondlayer/subgraphs": "^0.8.0",
+    "@secondlayer/subgraphs": "^0.9.0",
     "@biomejs/js-api": "^0.7.0",
     "@biomejs/wasm-nodejs": "^1.9.0",
     esbuild: "^0.19.0",
@@ -35226,6 +35226,9 @@ function mapType(abiType, nullable) {
 }
 
 // src/generators/subgraph-scaffold.ts
+function toCamelCase(str) {
+  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
 async function generateSubgraphScaffold(input2) {
   const { contractId, functions } = input2;
   const contractParts = contractId.split(".");
@@ -35235,6 +35238,12 @@ async function generateSubgraphScaffold(input2) {
   if (publicFunctions.length === 0) {
     throw new Error(`No public functions found in ${contractId}`);
   }
+  const sourceEntries = publicFunctions.map((fn) => {
+    const sourceName = toCamelCase(fn.name);
+    return `    ${sourceName}: { type: 'contract_call', contractId: '${contractId}', functionName: '${fn.name}' }`;
+  });
+  const sourcesBlock = sourceEntries.join(`,
+`);
   const tables = publicFunctions.map((fn) => {
     const columns = fn.args.map((arg) => {
       const mapped = clarityTypeToSubgraphColumn(arg.type);
@@ -35251,14 +35260,15 @@ ${columns || "        _placeholder: { type: 'text' }"}
   });
   const schemaBlock = tables.join(`,
 `);
-  const handlerKeys = publicFunctions.map((fn) => {
-    return `    '${contractId}::${fn.name}': async (event, ctx) => {
+  const handlerEntries = publicFunctions.map((fn) => {
+    const sourceName = toCamelCase(fn.name);
+    return `    ${sourceName}: async (event, ctx) => {
       // TODO: implement ${fn.name} handler
       // event.args contains the function arguments
       // ctx.insert('${fn.name.replace(/-/g, "_")}', { ... })
     }`;
   });
-  const handlersBlock = handlerKeys.join(`,
+  const handlersBlock = handlerEntries.join(`,
 
 `);
   const code = `
@@ -35266,7 +35276,9 @@ import { defineSubgraph } from '@secondlayer/subgraphs';
 
 export default defineSubgraph({
   name: '${subgraphName}',
-  sources: [{ contract: '${contractId}' }],
+  sources: {
+${sourcesBlock}
+  },
   schema: {
 ${schemaBlock}
   },
@@ -35279,12 +35291,12 @@ ${handlersBlock}
 }
 
 // src/utils/case-conversion.ts
-import { toCamelCase } from "@secondlayer/stacks/clarity";
+import { toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 function toPascalCase(str) {
-  return capitalize(toCamelCase(str));
+  return capitalize(toCamelCase2(str));
 }
 
 // src/generators/subgraphs.ts
@@ -35378,15 +35390,19 @@ export default defineSubgraph({
   description: "TODO: describe what this subgraph tracks",
 
   // Sources define what blockchain data this subgraph processes.
-  // Each source filters transactions/events by contract, type, function, or event.
-  // Examples:
-  //   { contract: "SP000...::my-contract" }              — all txs to a contract
-  //   { contract: "SP000...::my-contract", event: "transfer" } — specific event
-  //   { type: "stx_transfer", minAmount: 1000000n }      — STX transfers >= 1 STX
-  //   { contract: "*.pox-*" }                             — wildcard contract match
-  sources: [
-    { contract: "SP000000000000000000002Q6VF78.pox-4" },
-  ],
+  // Each source is named — the name becomes the handler key.
+  //
+  // Filter types:
+  //   { type: "ft_transfer", assetIdentifier: "SP...token::token-name" }
+  //   { type: "ft_mint", assetIdentifier: "SP...token::token-name" }
+  //   { type: "contract_call", contractId: "SP...contract", functionName: "swap" }
+  //   { type: "contract_deploy" }
+  //   { type: "print_event", contractId: "SP...contract", topic: "my-event" }
+  //   { type: "stx_transfer", minAmount: 1000000n }
+  //   { type: "nft_transfer", assetIdentifier: "SP...nft::nft-name" }
+  sources: {
+    handler: { type: "contract_call", contractId: "SP000000000000000000002Q6VF78.pox-4" },
+  },
 
   // Schema defines the tables this subgraph creates.
   // Each table gets auto-columns: _id, _block_height, _tx_id, _created_at.
@@ -35398,20 +35414,18 @@ export default defineSubgraph({
         amount: { type: "uint" },
         memo: { type: "text", nullable: true },
       },
-      // Optional composite indexes
-      // indexes: [["sender", "amount"]],
     },
   },
 
-  // Handlers process matched events and write to your tables via the context.
-  // Keys match source patterns (use sourceKey format), or "*" as catch-all.
-  // Context methods: ctx.insert(), ctx.update(), ctx.delete()
+  // Handlers process matched events. Keys must match source names.
+  // Context: ctx.insert(), ctx.update(), ctx.upsert(), ctx.patch(),
+  //          ctx.patchOrInsert(), ctx.findOne(), ctx.findMany()
   handlers: {
-    "*": async (event, ctx) => {
-      await ctx.insert("data", {
-        sender: event.sender ?? event.tx?.sender,
+    handler: (event, ctx) => {
+      ctx.insert("data", {
+        sender: ctx.tx.sender,
         amount: event.amount ?? 0,
-        memo: event.memo ?? null,
+        memo: null,
       });
     },
   },
@@ -35520,12 +35534,11 @@ Stopped watching.`);
           write: false
         });
         const handlerCode = new TextDecoder().decode(buildResult.outputFiles[0].contents);
-        const { sourceKey } = await import("@secondlayer/subgraphs");
         const result = await deploySubgraphApi({
           name: def.name,
           version: def.version,
           description: def.description,
-          sources: def.sources.map(sourceKey),
+          sources: def.sources,
           schema: def.schema,
           handlerCode,
           reindex: options2.reindex
@@ -37025,5 +37038,5 @@ registerWhoamiCommand(program);
 registerReceiverCommand(program);
 program.parse();
 
-//# debugId=2406566DC849ADA464756E2164756E21
+//# debugId=7DCC96BC6E5808DA64756E2164756E21
 //# sourceMappingURL=cli.js.map