@fragment-dev/cli 2026.9.10-13 → 2026.9.10-3

package/README.md

@@ -290,7 +290,7 @@ FLAGS
 DESCRIPTION
   Generate GraphQL queries from your Schema for your SDK.
 
-  This command generates a GraphQL query for each Ledger Entry type and each Payment type in your ledger Schema.
+  This command generates a GraphQL query for each entry type in your ledger Schema.
   Use this command with Fragment SDKs to create type-safe code to update your ledger.
 
 EXAMPLES

package/dist/{chunk-7GWSUHUD.js → chunk-4VYFUMLV.js}

@@ -1256,9 +1256,7 @@ mutation CreatePayment(
       payment {
         clientSecret
         ik
-        ledger {
-          id
-        }
+        ledgerId
         status
         amount
         type

package/dist/{chunk-3AKNNON2.js → chunk-5PGVOMOW.js}

@@ -27,10 +27,10 @@ import {
 } from "./chunk-PISSWWTD.js";
 import {
   VerifySchema
-} from "./chunk-NLJM26T4.js";
+} from "./chunk-JD2S54X7.js";
 import {
   GenGraphQL
-} from "./chunk-OAO4AP7N.js";
+} from "./chunk-BQZQLWCT.js";
 import {
   GetSchema
 } from "./chunk-T2BBIXGB.js";

package/dist/{chunk-N2R7NRAP.js → chunk-65EVYD2Y.js}

@@ -7089,8 +7089,7 @@ var codes = {
     request_body_mismatch: "ik_request_body_mismatch",
     concurrent_reverse_ledger_entry_request: "ik_concurrent_reverse_ledger_entry_request",
     repost_not_enabled: "ik_repost_not_enabled",
-    duplicate_ik_in_batch: "ik_duplicate_ik_in_batch",
-    reserved_prefix: "ik_reserved_prefix"
+    duplicate_ik_in_batch: "ik_duplicate_ik_in_batch"
   },
   ledger: {
     not_found: "ledger_not_found",
@@ -7120,8 +7119,7 @@ var codes = {
     missing_parameters: "payment_missing_parameters",
     unknown_parameters: "payment_unknown_parameters",
     reserved_parameters: "payment_reserved_parameters",
-    invalid_request: "payment_invalid_request",
-    confirmation_rejected: "payment_confirmation_rejected"
+    invalid_request: "payment_invalid_request"
   },
   payment_account: {
     direct_posting_disallowed: `payment_account_direct_posting_disallowed`,

package/dist/{chunk-OAO4AP7N.js → chunk-BQZQLWCT.js}

@@ -2,20 +2,19 @@ import {
   generateQueriesFileContent,
   generateQueryFiles,
   schemaToEntryDefinitions,
-  schemaToPaymentDefinitions,
   validateOutputName
-} from "./chunk-FYVAWYYH.js";
+} from "./chunk-KNG7UK5V.js";
 import {
   Schema,
   parseWithError
-} from "./chunk-LEJQJ3T3.js";
+} from "./chunk-R2HKKBEG.js";
 import {
   formatValidationErrors,
   logValidationErrors
-} from "./chunk-KDXCKOCB.js";
+} from "./chunk-J6HLIC77.js";
 import {
   BadRequestError
-} from "./chunk-N2R7NRAP.js";
+} from "./chunk-65EVYD2Y.js";
 import {
   FragmentCommand,
   require_lib
@@ -42,7 +41,7 @@ var GenGraphQL = class _GenGraphQL extends FragmentCommand {
     this.summary = "Generate GraphQL queries from your Schema for your SDK.";
   }
   static {
-    this.description = `This command generates a GraphQL query for each Ledger Entry type and each Payment type in your ledger Schema.
+    this.description = `This command generates a GraphQL query for each entry type in your ledger Schema.
   Use this command with Fragment SDKs to create type-safe code to update your ledger.`;
   }
   static {
@@ -138,12 +137,8 @@ ${import_chalk.default.gray("Schema file:")} ${path}`);
         schema: validatedSchema,
         includeRuntimeArgs: flags["include-runtime-args"]
       });
-      const paymentDefinitions = schemaToPaymentDefinitions({
-        schema: validatedSchema
-      });
       const generateQueryParams = {
         definitions: entryDefinitions,
-        paymentDefinitions,
         includeStandardQueries: flags["include-standard-queries"]
       };
       if (flags["output-file-per-query"]) {

package/dist/{chunk-IMRC5SWK.js → chunk-DJCFTORW.js}

@@ -1,13 +1,13 @@
 import {
   Schema,
   parseWithError
-} from "./chunk-LEJQJ3T3.js";
+} from "./chunk-R2HKKBEG.js";
 import {
   formatValidationErrors
-} from "./chunk-KDXCKOCB.js";
+} from "./chunk-J6HLIC77.js";
 import {
   BadRequestError
-} from "./chunk-N2R7NRAP.js";
+} from "./chunk-65EVYD2Y.js";
 import {
   init_cjs_shims
 } from "./chunk-7GH3YGSC.js";

package/dist/{chunk-KDXCKOCB.js → chunk-J6HLIC77.js}

@@ -1,6 +1,6 @@
 import {
   BadRequestError
-} from "./chunk-N2R7NRAP.js";
+} from "./chunk-65EVYD2Y.js";
 import {
   require_source
 } from "./chunk-XK2D2Z44.js";

package/dist/{chunk-NLJM26T4.js → chunk-JD2S54X7.js}

@@ -2,13 +2,13 @@ import {
   extractSchemaMetadata,
   isJsonParseError,
   validateSchemaStructure
-} from "./chunk-IMRC5SWK.js";
+} from "./chunk-DJCFTORW.js";
 import {
   DEFAULT_SCHEMA_PATH
 } from "./chunk-A4BSWX5D.js";
 import {
   logValidationErrors
-} from "./chunk-KDXCKOCB.js";
+} from "./chunk-J6HLIC77.js";
 import {
   FragmentCommand,
   require_lib

package/dist/{chunk-FYVAWYYH.js → chunk-KNG7UK5V.js}

@@ -1,14 +1,13 @@
 import {
   standardQueries
-} from "./chunk-7GWSUHUD.js";
+} from "./chunk-4VYFUMLV.js";
 import {
   InvalidGraphQlError
 } from "./chunk-ZMFGVGZP.js";
 import {
-  SYSTEM_PARAMETER_NAMES,
   getSchemaObjectParameters,
   getStructuralSubpaths
-} from "./chunk-MHYCVJGZ.js";
+} from "./chunk-NE5UNTYB.js";
 import {
   require_source
 } from "./chunk-XK2D2Z44.js";
@@ -27,16 +26,6 @@ var import_chalk = __toESM(require_source(), 1);
 var import_parser = __toESM(require_parser(), 1);
 var import_printer = __toESM(require_printer(), 1);
 import { statSync, existsSync } from "node:fs";
-
-// ../../libs/schema-validation/utils/paymentTypes.ts
-init_cjs_shims();
-var getRequiredPaymentParameters = (paymentType) => new Set(
-  getSchemaObjectParameters(paymentType, true).filter(
-    (name) => !SYSTEM_PARAMETER_NAMES.has(name)
-  )
-);
-
-// src/graphql.ts
 var getAccountParams = (accountPath, schema) => {
   const subpaths = getStructuralSubpaths(accountPath);
   return subpaths.flatMap(
@@ -117,16 +106,6 @@ var schemaToEntryDefinitions = ({
     ];
   });
 };
-var schemaToPaymentDefinitions = ({
-  schema
-}) => (schema.payments?.types ?? []).map((paymentType) => ({
-  paymentType: paymentType.type,
-  typeVersion: paymentType.typeVersion,
-  direction: paymentType.payment.direction,
-  // The same helper `createPayment` validates against, so the generated
-  // variables are exactly the parameters the API accepts.
-  parameters: Array.from(getRequiredPaymentParameters(paymentType))
-}));
 var camelCase = (value, delimiter) => {
   return value.split(delimiter).filter((x) => !!x).map((word, index) => {
     if (index === 0) {
@@ -209,80 +188,25 @@ __typename
 }
 ${OnErrorFragment}
 `;
-var PaymentFragment = `
-    ik
-    ledger {
-      id
-      ik
-    }
-    type
-    typeVersion
-    status
-    amount
-    mode
-    clientSecret
-    created
-`;
-var CreatePaymentFragment = `
-__typename
-... on CreatePaymentResult {
-  payment {
-    ${PaymentFragment}
-  }
-}
-${OnErrorFragment}
-`;
 var isValidGraphQlName = (name) => {
   return /^[a-zA-Z_]+[a-zA-Z0-9_]*$/.exec(name) !== null;
 };
-var toPascalCaseGraphQlName = (value) => camelCase(camelCase(value, "_"), "-").split("").map((ch, idx) => {
-  if (idx === 0) {
-    return ch.toUpperCase();
-  }
-  return ch;
-}).join("").replace(/\s+/g, "_").replace(/\./g, "_").replace(/[^a-zA-Z0-9_]/g, "").replace(/^(\d)/, "_$1");
-var versionSuffix = (typeVersion) => typeof typeVersion === "number" && typeVersion > 1 ? `_v${typeVersion}` : "";
-var OperationSubject = {
-  entry: "entry",
-  paymentType: "payment type"
-};
-var assertValidOperationName = ({
-  name,
-  subject,
-  sourceType
-}) => {
-  if (!isValidGraphQlName(name)) {
+var generateGraphQlEntryType = (entryType, typeVersion) => {
+  const readableEntryType = camelCase(camelCase(entryType, "_"), "-").split("").map((ch, idx) => {
+    if (idx === 0) {
+      return ch.toUpperCase();
+    }
+    return ch;
+  }).join("").replace(/\s+/g, "_").replace(/\./g, "_").replace(/[^a-zA-Z0-9_]/g, "").replace(/^(\d)/, "_$1").concat(typeVersion && typeVersion > 1 ? `_v${typeVersion}` : "");
+  if (!isValidGraphQlName(readableEntryType)) {
     throw new InvalidGraphQlError(
-      `Operation name ${name} (for ${subject}: ${import_chalk.default.yellow(
-        sourceType
+      `Operation name ${readableEntryType} (for entry: ${import_chalk.default.yellow(
+        entryType
       )}) is not a valid GraphQL name`
     );
   }
-};
-var generateGraphQlEntryType = (entryType, typeVersion) => {
-  const readableEntryType = toPascalCaseGraphQlName(entryType).concat(
-    versionSuffix(typeVersion)
-  );
-  assertValidOperationName({
-    name: readableEntryType,
-    subject: OperationSubject.entry,
-    sourceType: entryType
-  });
   return readableEntryType;
 };
-var generateGraphQlPaymentType = ({
-  paymentType,
-  direction,
-  typeVersion
-}) => {
-  const readablePaymentType = toPascalCaseGraphQlName(paymentType).concat(toPascalCaseGraphQlName(direction)).concat(versionSuffix(typeVersion));
-  assertValidOperationName({
-    name: readablePaymentType,
-    subject: OperationSubject.paymentType,
-    sourceType: paymentType
-  });
-  return readablePaymentType;
-};
 var getPredefinedParameters = (definition) => {
   const params = {};
   if (definition.method === "addLedgerEntry") {
@@ -382,64 +306,13 @@ var entryDefinitionToMutation = (definition) => {
     operationName
   };
 };
-var paymentPredefinedParameters = {
-  ik: "SafeString!",
-  ledgerIk: "SafeString!"
-};
-var paymentDefinitionToMutation = (definition) => {
-  const { paymentType, typeVersion, direction, parameters } = definition;
-  parameters.forEach((param) => {
-    if (!isValidGraphQlName(param)) {
-      throw new InvalidGraphQlError(
-        `Parameter name ${param} is not a valid GraphQL name`
-      );
-    }
-  });
-  const operationName = `CreatePayment${generateGraphQlPaymentType({
-    paymentType,
-    direction,
-    typeVersion
-  })}`;
-  const varArgs = [
-    ...Object.entries(paymentPredefinedParameters).map(
-      ([name, type]) => `$${name}: ${type}`
-    ),
-    ...parameters.filter(
-      (p) => !Object.prototype.hasOwnProperty.call(paymentPredefinedParameters, p)
-    ).map((p) => `$${p}: String!`)
-  ].join(",\n");
-  const command = [
-    `mutation ${operationName} (`,
-    `${varArgs}) {`,
-    `createPayment(`,
-    `ik: $ik,`,
-    `ledger: { ik: $ledgerIk },`,
-    `payment: {`,
-    `type: "${paymentType}",`,
-    `typeVersion: ${typeVersion},`
-  ];
-  if (parameters.length > 0) {
-    command.push(`parameters: {`);
-    command.push(parameters.map((p) => `${p}: $${p}`).join("\n"));
-    command.push(`}`);
-  }
-  command.push(`}) { ${CreatePaymentFragment} } }`);
-  return {
-    mutation: (0, import_printer.print)((0, import_parser.parse)(command.join(""))),
-    operationName
-  };
-};
 var generateQueriesFileContent = ({
   definitions,
-  paymentDefinitions,
   includeStandardQueries
 }) => {
-  const generatedCode = [
-    ...definitions.map((def) => entryDefinitionToMutation(def).mutation),
-    ...paymentDefinitions.map(
-      (def) => paymentDefinitionToMutation(def).mutation
-    )
-  ];
+  const generatedCode = definitions.map(
+    (def) => entryDefinitionToMutation(def).mutation
+  );
   if (includeStandardQueries) {
     generatedCode.push(standardQueries);
   }
@@ -448,17 +321,16 @@ var generateQueriesFileContent = ({
 };
 var generateQueryFiles = ({
   definitions,
-  paymentDefinitions,
   includeStandardQueries
 }) => {
-  const generatedCode = [
-    ...definitions.map((def) => entryDefinitionToMutation(def)),
-    ...paymentDefinitions.map((def) => paymentDefinitionToMutation(def))
-  ].map(({ operationName, mutation }) => ({
-    content: `${mutation}
+  const generatedCode = definitions.map((def) => {
+    const { operationName, mutation } = entryDefinitionToMutation(def);
+    return {
+      content: `${mutation}
 `,
-    fileName: `${operationName}.graphql`
-  }));
+      fileName: `${operationName}.graphql`
+    };
+  });
   if (includeStandardQueries) {
     const parsedStdQueries = (0, import_parser.parse)(standardQueries);
     parsedStdQueries.definitions.forEach((def) => {
@@ -494,14 +366,11 @@ var validateOutputName = ({
 
 export {
   schemaToEntryDefinitions,
-  schemaToPaymentDefinitions,
   camelCase,
   isValidGraphQlName,
   generateGraphQlEntryType,
-  generateGraphQlPaymentType,
   getPredefinedParameters,
   entryDefinitionToMutation,
-  paymentDefinitionToMutation,
   generateQueriesFileContent,
   generateQueryFiles,
   validateOutputName

package/dist/chunk-NE5UNTYB.js

@@ -0,0 +1,113 @@
+import {
+  BadRequestError,
+  assert_default,
+  codes,
+  getStringParametersInternal
+} from "./chunk-65EVYD2Y.js";
+import {
+  init_cjs_shims
+} from "./chunk-7GH3YGSC.js";
+
+// ../../libs/schema-validation/parameterization.ts
+init_cjs_shims();
+var fillParams = (obj, params = {}, options = {
+  allowMissing: false,
+  allowMissingInChildren: true
+}) => {
+  if (typeof obj === "string") {
+    const tokens = obj.split(/(\{\{[^{}]+?\}\})/g);
+    const missingParams = /* @__PURE__ */ new Set();
+    const result = tokens.map((token) => {
+      const match = token.match(/\{\{([^{}]+?)\}\}/);
+      if (match) {
+        const param = match[1];
+        const paramValue = params[param];
+        if (paramValue === void 0 || paramValue === null) {
+          missingParams.add(param);
+          return token;
+        }
+        return paramValue;
+      }
+      return token;
+    }).join("");
+    if (!options.allowMissing) {
+      assert_default(!missingParams.size, BadRequestError, {
+        message: `Failed to fill all parameters: ${obj} -> ${result}`,
+        code: codes.parameterization_failed
+      });
+    }
+    return result;
+  }
+  if (typeof obj === "object" && obj !== null) {
+    if (Array.isArray(obj)) {
+      return obj.map((value) => fillParams(value, params, options));
+    }
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        fillParams(value, params, {
+          ...options,
+          allowMissing: key === "children" ? options.allowMissingInChildren : options.allowMissing
+        })
+      ])
+    );
+  }
+  return obj;
+};
+function getSchemaObjectParametersInternal(obj, parameters, includeChildren) {
+  if (typeof obj === "string") {
+    getStringParametersInternal(obj, parameters);
+  } else if (typeof obj === "object") {
+    for (const key in obj) {
+      if (key !== "templatePath" && (key !== "children" || includeChildren)) {
+        getSchemaObjectParametersInternal(
+          obj[key],
+          parameters,
+          includeChildren
+        );
+      }
+    }
+  }
+}
+function getSchemaObjectParameters(obj, includeChildren = false) {
+  const params = /* @__PURE__ */ new Set();
+  getSchemaObjectParametersInternal(obj, params, includeChildren);
+  return Array.from(params);
+}
+
+// ../../libs/path-utils/path.ts
+init_cjs_shims();
+var getStructuralPath = (path) => {
+  return path.split("/").map((part) => part.split(":")[0]).join("/");
+};
+var getInstanceValueByAccountPath = (path) => {
+  const parts = path.split("/");
+  const result = /* @__PURE__ */ new Map();
+  let workingSet = "";
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    const [templateKey, templateValue] = part.split(":");
+    workingSet = workingSet ? `${workingSet}/${templateKey}` : templateKey;
+    result.set(workingSet, templateValue);
+    if (templateValue) {
+      workingSet = `${workingSet}:${templateValue}`;
+    }
+  }
+  return result;
+};
+var getSubpaths = (path) => path.split("/").reduce((acc, part) => {
+  const prev = acc[acc.length - 1];
+  const subPath = prev ? `${prev}/${part}` : part;
+  acc.push(subPath);
+  return acc;
+}, []);
+var getStructuralSubpaths = (path) => getSubpaths(getStructuralPath(path));
+
+export {
+  fillParams,
+  getSchemaObjectParameters,
+  getStructuralPath,
+  getInstanceValueByAccountPath,
+  getSubpaths,
+  getStructuralSubpaths
+};