@fragment-dev/cli 2026.9.10-2 → 2026.9.10-5

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 entry type in your ledger Schema.
+  This command generates a GraphQL query for each Ledger Entry type and each Payment type in your ledger Schema.
   Use this command with Fragment SDKs to create type-safe code to update your ledger.
 
 EXAMPLES

package/dist/{chunk-DJCFTORW.js → chunk-2LCTKBU3.js}

@@ -1,7 +1,7 @@
 import {
   Schema,
   parseWithError
-} from "./chunk-R2HKKBEG.js";
+} from "./chunk-RILSVR74.js";
 import {
   formatValidationErrors
 } from "./chunk-J6HLIC77.js";

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

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

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

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

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

@@ -2,7 +2,7 @@ import {
   extractSchemaMetadata,
   isJsonParseError,
   validateSchemaStructure
-} from "./chunk-DJCFTORW.js";
+} from "./chunk-2LCTKBU3.js";
 import {
   DEFAULT_SCHEMA_PATH
 } from "./chunk-A4BSWX5D.js";

package/dist/chunk-FUUGVGYY.js

@@ -0,0 +1,424 @@
+import {
+  BadRequestError,
+  CurrencyMatchInputSchema,
+  CurrencyModeSchema,
+  LedgerAccountTypeSchema,
+  ParameterizedString,
+  SafeStringSchema,
+  assert_default,
+  codes,
+  getStringParametersInternal,
+  z
+} 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));
+
+// ../../libs/types/tx.ts
+init_cjs_shims();
+var SchemaTxMatchInput = z.object({
+  id: z.optional(ParameterizedString),
+  externalId: z.optional(ParameterizedString)
+});
+var txTypes = ["credit", "debit"];
+var TxTypeSchema = z.enum(txTypes);
+
+// ../../libs/types/schemas.ts
+init_cjs_shims();
+var LedgerMigrationStatusSchema = z.enum([
+  "queued",
+  "started",
+  "failed",
+  "completed",
+  "skipped"
+]);
+var SafeRecordKey = z.string().refine((v) => v !== "__proto__", "invalid parameter name");
+var ParametersSchema = z.record(
+  SafeRecordKey,
+  z.string({
+    invalid_type_error: "Invalid parameter type. All parameters must be string-encoded values."
+  })
+);
+var EntryParametersSchema = z.record(
+  SafeRecordKey,
+  z.union([
+    z.string({
+      invalid_type_error: "Invalid parameter type. Parameters must be string-encoded values or arrays of objects with string values."
+    }),
+    z.array(z.record(SafeRecordKey, z.string()))
+  ])
+);
+var ConsistencyModeSchema = z.enum(["strong", "eventual"]);
+var ConsistencyConfigSchema = (keys, extra) => {
+  const v = z.optional(ConsistencyModeSchema);
+  const schemaObject = Object.fromEntries(
+    keys.map((key) => [key, v])
+  );
+  return z.object({ ...extra, ...schemaObject });
+};
+var GroupConsistencyConfig = z.object({
+  key: SafeStringSchema,
+  ownBalanceUpdates: ConsistencyModeSchema
+});
+var AccountConsistencyConfigSchema = z.object({
+  lines: z.optional(ConsistencyModeSchema),
+  ownBalanceUpdates: z.optional(ConsistencyModeSchema),
+  totalBalanceUpdates: z.optional(ConsistencyModeSchema),
+  groups: z.optional(z.array(GroupConsistencyConfig))
+});
+var SchemaCurrencyMatchInput = z.object({
+  customCurrencyId: z.string().optional(),
+  code: z.string()
+});
+var SchemaLinkTypeList = [
+  "IncreaseLink",
+  "UnitLink",
+  "CustomLink",
+  "StripeLink"
+];
+var SchemaLinkType = z.enum(SchemaLinkTypeList);
+var SchemaExternalAccountMatchInput = z.object({
+  linkType: SchemaLinkType.optional(),
+  id: z.string().optional(),
+  externalId: z.string().optional(),
+  linkId: z.string().optional()
+});
+var SchemaPaymentInput = z.object({
+  enabled: z.boolean()
+});
+var SchemaLedgerEntityStatusSchema = z.enum([
+  "active",
+  "disabled",
+  "archived"
+]);
+var BaseSchemaLedgerAccountInput = z.lazy(
+  () => z.object({
+    key: z.string(),
+    name: z.string().optional(),
+    type: LedgerAccountTypeSchema.optional(),
+    currency: SchemaCurrencyMatchInput.optional(),
+    currencyMode: CurrencyModeSchema.optional(),
+    template: z.boolean().optional(),
+    clearing: z.boolean().optional(),
+    children: z.array(BaseSchemaLedgerAccountInput).optional(),
+    linkedAccount: SchemaExternalAccountMatchInput.optional(),
+    payment: SchemaPaymentInput.optional(),
+    consistencyConfig: AccountConsistencyConfigSchema.optional(),
+    status: SchemaLedgerEntityStatusSchema.optional()
+  })
+);
+var BaseChartOfAccounts = z.object({
+  defaultConsistencyConfig: AccountConsistencyConfigSchema.optional(),
+  defaultCurrency: z.optional(CurrencyMatchInputSchema),
+  defaultCurrencyMode: CurrencyModeSchema.optional(),
+  accounts: z.array(BaseSchemaLedgerAccountInput)
+});
+var SchemaCondition = z.object({
+  ownBalance: z.object({
+    eq: z.string().optional(),
+    lte: z.string().optional(),
+    gte: z.string().optional()
+  }).optional(),
+  totalBalance: z.object({
+    eq: z.string().optional(),
+    lte: z.string().optional(),
+    gte: z.string().optional()
+  }).optional()
+});
+var PostLinesAsSchema = z.enum([
+  "raw_lines",
+  "net_amounts",
+  "skip_zero_lines"
+]);
+var BaseSchemaLedgerEntryConditionInput = z.object({
+  account: z.object({ path: z.string() }).optional(),
+  postcondition: SchemaCondition.optional(),
+  precondition: SchemaCondition.optional(),
+  currency: SchemaCurrencyMatchInput.optional(),
+  repeated: z.object({
+    key: SafeStringSchema.refine((k) => k.trim().length >= 1, {
+      message: "repeated.key cannot be empty"
+    })
+  }).optional()
+});
+var BaseSchemaLedgerLineTagInput = z.object({
+  key: z.string(),
+  value: z.string()
+});
+var BaseSchemaLedgerEntryLineInput = z.object({
+  account: z.object({ path: z.string() }).optional(),
+  amount: z.string().optional(),
+  key: z.string(),
+  currency: SchemaCurrencyMatchInput.optional(),
+  description: z.string().optional(),
+  tx: SchemaTxMatchInput.optional(),
+  tags: z.array(BaseSchemaLedgerLineTagInput).optional(),
+  repeated: z.object({
+    key: SafeStringSchema.refine((k) => k.trim().length >= 1, {
+      message: "repeated.key cannot be empty"
+    })
+  }).optional()
+});
+var BaseSchemaLedgerEntryInput = z.object({
+  type: z.string(),
+  typeVersion: z.number().int().optional(),
+  description: z.string().optional(),
+  conditions: z.array(BaseSchemaLedgerEntryConditionInput).optional(),
+  lines: z.array(BaseSchemaLedgerEntryLineInput).optional(),
+  parameters: z.record(SafeRecordKey, z.string()).optional(),
+  tags: z.array(
+    z.object({
+      key: z.string(),
+      value: z.string()
+    })
+  ).optional(),
+  groups: z.array(
+    z.object({
+      key: SafeStringSchema,
+      value: z.string()
+    })
+  ).optional(),
+  status: SchemaLedgerEntityStatusSchema.optional(),
+  postLinesAs: PostLinesAsSchema.optional()
+});
+var BaseLedgerEntries = z.object({
+  types: z.array(BaseSchemaLedgerEntryInput)
+});
+var PaymentEventKey = {
+  /** Exit from the payer not yet having supplied a payment method at checkout. */
+  needs_payment_method_to_processing: "needs_payment_method_to_processing",
+  processing_to_settled: "processing_to_settled"
+};
+var PaymentEventKeySchema = z.nativeEnum(PaymentEventKey);
+var PaymentTypeDirection = {
+  payin: "payin",
+  payout: "payout"
+};
+var PaymentTypeDirectionSchema = z.nativeEnum(PaymentTypeDirection);
+var SystemLineKind = {
+  payment_settlement_line: "payment_settlement_line",
+  payment_fee_line: "payment_fee_line"
+};
+var SystemLineKindSchema = z.nativeEnum(SystemLineKind);
+var SystemLineParameterName = {
+  payment_settlement_line: "settled_amount",
+  payment_fee_line: "fragment_fee_amount"
+};
+var SYSTEM_LINE_AMOUNT = {
+  [SystemLineKind.payment_settlement_line]: `{{${SystemLineParameterName.payment_settlement_line}}}`,
+  [SystemLineKind.payment_fee_line]: `-{{${SystemLineParameterName.payment_fee_line}}}`
+};
+var SYSTEM_PARAMETER_NAMES = new Set(
+  Object.values(SystemLineParameterName)
+);
+var BaseSchemaPaymentInput = z.object({
+  amount: z.string(),
+  direction: PaymentTypeDirectionSchema
+});
+var BaseSchemaPaymentEntryLineInput = BaseSchemaLedgerEntryLineInput.pick({
+  key: true,
+  currency: true,
+  description: true
+}).extend({
+  account: z.object({ path: z.string() }),
+  amount: z.string(),
+  system: SystemLineKindSchema.optional()
+});
+var BaseSchemaPaymentEntryInput = z.object({
+  description: z.string().optional(),
+  lines: z.array(BaseSchemaPaymentEntryLineInput)
+});
+var SchemaPaymentTypeStatusSchema = z.enum(["active"]);
+var BaseSchemaPaymentTypeInput = z.object({
+  type: z.string(),
+  typeVersion: z.number().int(),
+  status: SchemaPaymentTypeStatusSchema,
+  payment: BaseSchemaPaymentInput,
+  accounting: z.object({
+    needs_payment_method_to_processing: BaseSchemaPaymentEntryInput.optional(),
+    processing_to_settled: BaseSchemaPaymentEntryInput
+  })
+});
+var BaseSchemaPayments = z.object({
+  types: z.array(BaseSchemaPaymentTypeInput)
+});
+var SceneEntrySchema = z.object({
+  type: z.string(),
+  typeVersion: z.number().int().positive().optional(),
+  parameters: z.record(SafeRecordKey, z.string())
+});
+var ScenePaymentSchema = z.object({
+  ik: z.string(),
+  type: z.string(),
+  typeVersion: z.number().int().positive().optional(),
+  parameters: z.record(SafeRecordKey, z.string())
+});
+var SceneLedgerEventSchema = z.object({
+  eventType: z.literal("entry"),
+  entry: SceneEntrySchema
+});
+var ScenePaymentEventSchema = z.object({
+  eventType: z.literal("payment"),
+  payment: z.object({
+    ik: z.string(),
+    event: PaymentEventKeySchema
+  })
+});
+var SceneEventSchema = z.discriminatedUnion("eventType", [
+  SceneLedgerEventSchema,
+  ScenePaymentEventSchema
+]);
+var BaseScene = z.object({
+  name: z.string(),
+  events: z.array(SceneEventSchema),
+  payments: z.array(ScenePaymentSchema).optional()
+});
+var EntryKey = z.object({
+  type: SafeStringSchema,
+  typeVersion: z.number().int().positive()
+});
+var SchemaLedgerAccountMatchInput = z.object({
+  path: ParameterizedString
+});
+var GroupReconciliationParameters = z.object({
+  clearingAccountPath: SchemaLedgerAccountMatchInput
+});
+var SchemaEntryGroup = z.object({
+  key: SafeStringSchema,
+  description: z.string().optional(),
+  reconciliation: GroupReconciliationParameters.optional()
+});
+var BaseSchema = z.object({
+  name: z.string().optional(),
+  key: z.string(),
+  chartOfAccounts: BaseChartOfAccounts,
+  ledgerEntries: BaseLedgerEntries.optional(),
+  payments: BaseSchemaPayments.optional(),
+  groups: z.array(SchemaEntryGroup).optional(),
+  scenes: z.array(BaseScene).optional(),
+  consistencyConfig: z.optional(
+    z.object({
+      entries: ConsistencyModeSchema.optional()
+    })
+  )
+});
+
+export {
+  fillParams,
+  getSchemaObjectParameters,
+  SchemaTxMatchInput,
+  ConsistencyConfigSchema,
+  AccountConsistencyConfigSchema,
+  SchemaLedgerEntityStatusSchema,
+  BaseChartOfAccounts,
+  PostLinesAsSchema,
+  PaymentEventKey,
+  PaymentEventKeySchema,
+  PaymentTypeDirection,
+  PaymentTypeDirectionSchema,
+  SystemLineKind,
+  SystemLineKindSchema,
+  SYSTEM_LINE_AMOUNT,
+  SYSTEM_PARAMETER_NAMES,
+  SchemaPaymentTypeStatusSchema,
+  SchemaEntryGroup,
+  getStructuralPath,
+  getInstanceValueByAccountPath,
+  getSubpaths,
+  getStructuralSubpaths
+};

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

@@ -2,12 +2,13 @@ import {
   generateQueriesFileContent,
   generateQueryFiles,
   schemaToEntryDefinitions,
+  schemaToPaymentDefinitions,
   validateOutputName
-} from "./chunk-KNG7UK5V.js";
+} from "./chunk-QUNR5ZC3.js";
 import {
   Schema,
   parseWithError
-} from "./chunk-R2HKKBEG.js";
+} from "./chunk-RILSVR74.js";
 import {
   formatValidationErrors,
   logValidationErrors
@@ -41,7 +42,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 entry type in your ledger Schema.
+    this.description = `This command generates a GraphQL query for each Ledger Entry type and each Payment type in your ledger Schema.
   Use this command with Fragment SDKs to create type-safe code to update your ledger.`;
   }
   static {
@@ -137,8 +138,12 @@ ${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"]) {