@wildo-ai/saas-backend-lib 1.1.2 → 1.1.4

package/dist/esm/billing/batches/billing-reconciliation.batch.backend.service.js

@@ -0,0 +1,90 @@
+/**
+ * Billing Reconciliation — the scheduled tick that asks the provider what it actually holds.
+ *
+ * ## What this batch is for
+ *
+ * Local billing state is entirely webhook-derived. `StandardBilling_Interface.retrieveSubscription`
+ * documents itself as the read for "reconciliation (if webhook missed)", and until 2026-09-09 its
+ * only callers were inside the webhook router — so the recovery read ran exactly when a webhook
+ * DID arrive, and never when one did not. A lost delivery left a stale subscription still granting
+ * entitlements, or an invoice that existed only at the provider, with nothing anywhere that could
+ * notice.
+ *
+ * ## Why every number is reported and not just a total
+ *
+ * `subscriptionsExamined` is a health metric and `subscriptionsDrifted` is an ALARM. A steady
+ * non-zero drift count does not mean the sweep is working — it means webhook delivery is failing
+ * and the sweep is papering over it, which is a different problem with a different fix. Reporting
+ * one number would hide exactly that distinction.
+ *
+ * ## Failures are per row and the run keeps going
+ *
+ * One unreachable subscription must not stop the rest of the application from being reconciled: an
+ * unreconciled row is picked up by the next tick at no cost, so continuing is free and stopping
+ * costs a whole cycle. The same trade the usage flush makes.
+ */
+import { z } from 'zod';
+import { createCustomBatchExecutionService } from '../../base-classes/services/batches/batches-cronjobs-custom-execution.service.js';
+import { ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST } from '../../base-classes/services/batches/engine-custom-batch-manifests.js';
+import { SAAS_SERVICE_TYPES } from '../../inject/models/service-types.js';
+const BillingReconciliationInputSchema = z.object({});
+const BillingReconciliationOutputSchema = z.object({
+    /** Live subscriptions carrying a provider link that this run looked at. */
+    subscriptionsExamined: z.number().int().min(0),
+    /** Left alone because a local mutation had just touched them — postponed, not skipped forever. */
+    subscriptionsSkippedRecentlyMutated: z.number().int().min(0),
+    /** Rows that DISAGREED with the provider. Persistently non-zero means webhooks are being lost. */
+    subscriptionsDrifted: z.number().int().min(0),
+    subscriptionsRepaired: z.number().int().min(0),
+    /** Rows whose provider state could not be read. Reported; local state deliberately untouched. */
+    subscriptionsUnreadable: z.number().int().min(0),
+    billingAccountsExamined: z.number().int().min(0),
+    invoicesExamined: z.number().int().min(0),
+    /** Invoices that existed at the provider and nowhere locally. Each one is a lost webhook. */
+    invoicesRecovered: z.number().int().min(0),
+    invoiceStatusesRepaired: z.number().int().min(0),
+    errors: z.number().int().min(0),
+    durationMs: z.number().int().min(0),
+});
+export function createBillingReconciliationBatch() {
+    return createCustomBatchExecutionService({
+        input: BillingReconciliationInputSchema,
+        output: BillingReconciliationOutputSchema,
+        batchCronjob_Context: {
+            kind: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.kind,
+            resourceIdentifier: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.resourceIdentifier,
+            operationIdentifier: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.operationIdentifier,
+            cronJobExpression: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.cronExpression,
+        },
+        resolveDependencies: ({ get }) => ({
+            reconciliation: get(SAAS_SERVICE_TYPES.BillingReconciliationService),
+        }),
+        doHandle: async (_input, { logger, dependencies }) => {
+            const startTime = Date.now();
+            const result = await dependencies.reconciliation.reconcile();
+            /*
+             * Every line is logged individually rather than only counted, because each one names a
+             * specific subscription or invoice. `error` level throughout: a repaired drift is not good
+             * news — it is the record that a webhook was lost and that a customer's entitlements were
+             * wrong until this tick — and an unreadable subscription is state nobody can vouch for.
+             */
+            for (const message of result.errors) {
+                logger.error('Billing reconciliation finding', { message });
+            }
+            return {
+                subscriptionsExamined: result.subscriptionsExamined,
+                subscriptionsSkippedRecentlyMutated: result.subscriptionsSkippedRecentlyMutated,
+                subscriptionsDrifted: result.subscriptionsDrifted,
+                subscriptionsRepaired: result.subscriptionsRepaired,
+                subscriptionsUnreadable: result.subscriptionsUnreadable,
+                billingAccountsExamined: result.billingAccountsExamined,
+                invoicesExamined: result.invoicesExamined,
+                invoicesRecovered: result.invoicesRecovered,
+                invoiceStatusesRepaired: result.invoiceStatusesRepaired,
+                errors: result.errors.length,
+                durationMs: Date.now() - startTime,
+            };
+        },
+    });
+}
+//# sourceMappingURL=billing-reconciliation.batch.backend.service.js.map

package/dist/esm/billing/batches/billing-reconciliation.batch.backend.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing-reconciliation.batch.backend.service.js","sourceRoot":"","sources":["../../../../src/billing/batches/billing-reconciliation.batch.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iCAAiC,EAAE,MAAM,4FAA4F,CAAC;AAC/I,OAAO,EAAE,4CAA4C,EAAE,MAAM,gFAAgF,CAAC;AAC9I,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAGpF,MAAM,gCAAgC,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAEtD,MAAM,iCAAiC,GAAG,CAAC,CAAC,MAAM,CAAC;IACjD,2EAA2E;IAC3E,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9C,kGAAkG;IAClG,mCAAmC,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5D,kGAAkG;IAClG,oBAAoB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7C,qBAAqB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9C,iGAAiG;IACjG,uBAAuB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAChD,uBAAuB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAChD,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACzC,6FAA6F;IAC7F,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1C,uBAAuB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAChD,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACpC,CAAC,CAAC;AAEH,MAAM,UAAU,gCAAgC;IAC9C,OAAO,iCAAiC,CAAC;QACvC,KAAK,EAAE,gCAAgC;QACvC,MAAM,EAAE,iCAAiC;QACzC,oBAAoB,EAAE;YACpB,IAAI,EAAE,4CAA4C,CAAC,IAAI;YACvD,kBAAkB,EAAE,4CAA4C,CAAC,kBAAkB;YACnF,mBAAmB,EAAE,4CAA4C,CAAC,mBAAmB;YACrF,iBAAiB,EAAE,4CAA4C,CAAC,cAAc;SAC/E;QACD,mBAAmB,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC;YACjC,cAAc,EAAE,GAAG,CAAsC,kBAAkB,CAAC,4BAA4B,CAAC;SAC1G,CAAC;QACF,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE;YACnD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAE7B,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,cAAc,CAAC,SAAS,EAAE,CAAC;YAE7D;;;;;eAKG;YACH,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBACpC,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;YAC9D,CAAC;YAED,OAAO;gBACL,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;gBACnD,mCAAmC,EAAE,MAAM,CAAC,mCAAmC;gBAC/E,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;gBACjD,qBAAqB,EAAE,MAAM,CAAC,qBAAqB;gBACnD,uBAAuB,EAAE,MAAM,CAAC,uBAAuB;gBACvD,uBAAuB,EAAE,MAAM,CAAC,uBAAuB;gBACvD,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;gBACzC,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;gBAC3C,uBAAuB,EAAE,MAAM,CAAC,uBAAuB;gBACvD,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM;gBAC5B,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;aACnC,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Billing Reconciliation — the scheduled tick that asks the provider what it actually holds.\n *\n * ## What this batch is for\n *\n * Local billing state is entirely webhook-derived. `StandardBilling_Interface.retrieveSubscription`\n * documents itself as the read for \"reconciliation (if webhook missed)\", and until 2026-09-09 its\n * only callers were inside the webhook router — so the recovery read ran exactly when a webhook\n * DID arrive, and never when one did not. A lost delivery left a stale subscription still granting\n * entitlements, or an invoice that existed only at the provider, with nothing anywhere that could\n * notice.\n *\n * ## Why every number is reported and not just a total\n *\n * `subscriptionsExamined` is a health metric and `subscriptionsDrifted` is an ALARM. A steady\n * non-zero drift count does not mean the sweep is working — it means webhook delivery is failing\n * and the sweep is papering over it, which is a different problem with a different fix. Reporting\n * one number would hide exactly that distinction.\n *\n * ## Failures are per row and the run keeps going\n *\n * One unreachable subscription must not stop the rest of the application from being reconciled: an\n * unreconciled row is picked up by the next tick at no cost, so continuing is free and stopping\n * costs a whole cycle. The same trade the usage flush makes.\n */\n\nimport { z } from 'zod';\nimport { createCustomBatchExecutionService } from '~wildo-backend-lib/base-classes/services/batches/batches-cronjobs-custom-execution.service';\nimport { ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST } from '~wildo-backend-lib/base-classes/services/batches/engine-custom-batch-manifests';\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport type { BillingReconciliationBackendService } from '~wildo-backend-lib/billing/services/back-office/billing-reconciliation.backend.service';\n\nconst BillingReconciliationInputSchema = z.object({});\n\nconst BillingReconciliationOutputSchema = z.object({\n  /** Live subscriptions carrying a provider link that this run looked at. */\n  subscriptionsExamined: z.number().int().min(0),\n  /** Left alone because a local mutation had just touched them — postponed, not skipped forever. */\n  subscriptionsSkippedRecentlyMutated: z.number().int().min(0),\n  /** Rows that DISAGREED with the provider. Persistently non-zero means webhooks are being lost. */\n  subscriptionsDrifted: z.number().int().min(0),\n  subscriptionsRepaired: z.number().int().min(0),\n  /** Rows whose provider state could not be read. Reported; local state deliberately untouched. */\n  subscriptionsUnreadable: z.number().int().min(0),\n  billingAccountsExamined: z.number().int().min(0),\n  invoicesExamined: z.number().int().min(0),\n  /** Invoices that existed at the provider and nowhere locally. Each one is a lost webhook. */\n  invoicesRecovered: z.number().int().min(0),\n  invoiceStatusesRepaired: z.number().int().min(0),\n  errors: z.number().int().min(0),\n  durationMs: z.number().int().min(0),\n});\n\nexport function createBillingReconciliationBatch(): ReturnType<typeof createCustomBatchExecutionService> {\n  return createCustomBatchExecutionService({\n    input: BillingReconciliationInputSchema,\n    output: BillingReconciliationOutputSchema,\n    batchCronjob_Context: {\n      kind: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.kind,\n      resourceIdentifier: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.resourceIdentifier,\n      operationIdentifier: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.operationIdentifier,\n      cronJobExpression: ENGINE_BILLING_RECONCILIATION_BATCH_MANIFEST.cronExpression,\n    },\n    resolveDependencies: ({ get }) => ({\n      reconciliation: get<BillingReconciliationBackendService>(SAAS_SERVICE_TYPES.BillingReconciliationService),\n    }),\n    doHandle: async (_input, { logger, dependencies }) => {\n      const startTime = Date.now();\n\n      const result = await dependencies.reconciliation.reconcile();\n\n      /*\n       * Every line is logged individually rather than only counted, because each one names a\n       * specific subscription or invoice. `error` level throughout: a repaired drift is not good\n       * news — it is the record that a webhook was lost and that a customer's entitlements were\n       * wrong until this tick — and an unreadable subscription is state nobody can vouch for.\n       */\n      for (const message of result.errors) {\n        logger.error('Billing reconciliation finding', { message });\n      }\n\n      return {\n        subscriptionsExamined: result.subscriptionsExamined,\n        subscriptionsSkippedRecentlyMutated: result.subscriptionsSkippedRecentlyMutated,\n        subscriptionsDrifted: result.subscriptionsDrifted,\n        subscriptionsRepaired: result.subscriptionsRepaired,\n        subscriptionsUnreadable: result.subscriptionsUnreadable,\n        billingAccountsExamined: result.billingAccountsExamined,\n        invoicesExamined: result.invoicesExamined,\n        invoicesRecovered: result.invoicesRecovered,\n        invoiceStatusesRepaired: result.invoiceStatusesRepaired,\n        errors: result.errors.length,\n        durationMs: Date.now() - startTime,\n      };\n    },\n  });\n}\n"]}

package/dist/esm/billing/batches/usage-flush.batch.backend.service.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Usage Flush — reports recorded metered usage to the billing provider.
+ *
+ * ## What this batch is for
+ *
+ * It is the LAST HOP to money for every METERED product, and until 2026-09-08 it did not exist.
+ * `UsageMeteringBackendService.flushToProvider` had no caller anywhere — not in the engine, not in
+ * the platform, not in either dogfood application — so a metered product could be declared, priced
+ * and synced to the provider while no usage was ever reported (#415). Everything up to the local
+ * `usageRecords` row worked; the hop that turns a row into a charge was missing, and the resources
+ * registry's own comment already said no cron called it.
+ *
+ * ## The cadence here is a CEILING, not the interval
+ *
+ * Each product authors `metering.flushIntervalMinutes`, and the flush decides PER PRODUCT whether
+ * enough time has passed since its oldest pending row. This tick only has to be at least as fast as
+ * the fastest interval an author can reasonably want; when nothing is due it costs one indexed query
+ * per billing scope returning nothing.
+ *
+ * A slower default would silently cap every product's authored interval at the tick — which is
+ * precisely the defect this issue is about: an authored value the runtime quietly overrides.
+ *
+ * ## Why the run reports quantities and not only rows
+ *
+ * Getting metering wrong moves money in BOTH directions and neither direction announces itself: an
+ * under-report is revenue that never appears, an over-report is a customer charged twice. A count of
+ * ROWS can see neither, because rows carry quantities — ten rows reported can be any amount at all.
+ * So the output states what was due and what was sent, and a mismatch is raised as an error rather
+ * than left as two numbers a reader is expected to compare.
+ *
+ * ## Failure is per group, and the run keeps going
+ *
+ * One account's provider failure must not stop every other account's usage from being reported: an
+ * unreported row stays selectable by the next run, so continuing costs nothing and stopping costs a
+ * whole cycle. The one exception is a pending set so large it trips the drain's runaway guard, where
+ * the scope reports NOTHING deliberately — see `listAllUnreportedRecords`.
+ *
+ * assurance-control: WILDO.BILLING.USAGE_REPORTING — metered usage recorded against an account is
+ * reported to the billing provider on a schedule, and each run reconciles what it sent against what
+ * was due.
+ */
+import { createCustomBatchExecutionService } from '../../base-classes/services/batches/batches-cronjobs-custom-execution.service';
+export declare function createUsageFlushBatch(): ReturnType<typeof createCustomBatchExecutionService>;
+//# sourceMappingURL=usage-flush.batch.backend.service.d.ts.map

package/dist/esm/billing/batches/usage-flush.batch.backend.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-flush.batch.backend.service.d.ts","sourceRoot":"","sources":["../../../../src/billing/batches/usage-flush.batch.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,EAAE,iCAAiC,EAAE,MAAM,4FAA4F,CAAC;AAqB/I,wBAAgB,qBAAqB,IAAI,UAAU,CAAC,OAAO,iCAAiC,CAAC,CAyC5F"}

package/dist/esm/billing/batches/usage-flush.batch.backend.service.js

@@ -0,0 +1,99 @@
+/**
+ * Usage Flush — reports recorded metered usage to the billing provider.
+ *
+ * ## What this batch is for
+ *
+ * It is the LAST HOP to money for every METERED product, and until 2026-09-08 it did not exist.
+ * `UsageMeteringBackendService.flushToProvider` had no caller anywhere — not in the engine, not in
+ * the platform, not in either dogfood application — so a metered product could be declared, priced
+ * and synced to the provider while no usage was ever reported (#415). Everything up to the local
+ * `usageRecords` row worked; the hop that turns a row into a charge was missing, and the resources
+ * registry's own comment already said no cron called it.
+ *
+ * ## The cadence here is a CEILING, not the interval
+ *
+ * Each product authors `metering.flushIntervalMinutes`, and the flush decides PER PRODUCT whether
+ * enough time has passed since its oldest pending row. This tick only has to be at least as fast as
+ * the fastest interval an author can reasonably want; when nothing is due it costs one indexed query
+ * per billing scope returning nothing.
+ *
+ * A slower default would silently cap every product's authored interval at the tick — which is
+ * precisely the defect this issue is about: an authored value the runtime quietly overrides.
+ *
+ * ## Why the run reports quantities and not only rows
+ *
+ * Getting metering wrong moves money in BOTH directions and neither direction announces itself: an
+ * under-report is revenue that never appears, an over-report is a customer charged twice. A count of
+ * ROWS can see neither, because rows carry quantities — ten rows reported can be any amount at all.
+ * So the output states what was due and what was sent, and a mismatch is raised as an error rather
+ * than left as two numbers a reader is expected to compare.
+ *
+ * ## Failure is per group, and the run keeps going
+ *
+ * One account's provider failure must not stop every other account's usage from being reported: an
+ * unreported row stays selectable by the next run, so continuing costs nothing and stopping costs a
+ * whole cycle. The one exception is a pending set so large it trips the drain's runaway guard, where
+ * the scope reports NOTHING deliberately — see `listAllUnreportedRecords`.
+ *
+ * assurance-control: WILDO.BILLING.USAGE_REPORTING — metered usage recorded against an account is
+ * reported to the billing provider on a schedule, and each run reconciles what it sent against what
+ * was due.
+ */
+import { z } from 'zod';
+import { createCustomBatchExecutionService } from '../../base-classes/services/batches/batches-cronjobs-custom-execution.service.js';
+import { ENGINE_USAGE_FLUSH_BATCH_MANIFEST } from '../../base-classes/services/batches/engine-custom-batch-manifests.js';
+import { SAAS_SERVICE_TYPES } from '../../inject/models/service-types.js';
+const UsageFlushInputSchema = z.object({});
+const UsageFlushOutputSchema = z.object({
+    /** Rows that were DUE this run — not rows pending, which is larger while a product is still waiting. */
+    totalRecords: z.number().int().min(0),
+    /** Rows successfully marked reported. */
+    reported: z.number().int().min(0),
+    /** Rows that were not reported, or were reported and could not be marked. */
+    failed: z.number().int().min(0),
+    /** Quantity of usage that was due, and quantity the provider was told about. Meant to be equal. */
+    quantityRecorded: z.number().min(0),
+    quantityReported: z.number().min(0),
+    errors: z.number().int().min(0),
+    durationMs: z.number().int().min(0),
+});
+export function createUsageFlushBatch() {
+    return createCustomBatchExecutionService({
+        input: UsageFlushInputSchema,
+        output: UsageFlushOutputSchema,
+        batchCronjob_Context: {
+            kind: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.kind,
+            resourceIdentifier: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.resourceIdentifier,
+            operationIdentifier: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.operationIdentifier,
+            cronJobExpression: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.cronExpression,
+        },
+        resolveDependencies: ({ get }) => ({
+            usageMetering: get(SAAS_SERVICE_TYPES.UsageMeteringService),
+        }),
+        doHandle: async (_input, { logger, dependencies }) => {
+            const startTime = Date.now();
+            const result = await dependencies.usageMetering.flushToProvider();
+            /*
+             * Every error is logged individually rather than only counted, because each one names a
+             * specific account and product whose usage did not reach the provider. A count tells an
+             * operator that something is wrong; only the line tells them whose money it is.
+             *
+             * `error` level, not `warn`: unreported usage is revenue that will not be billed unless someone
+             * acts, and the reconciliation line among these is the one that says how much.
+             */
+            for (const message of result.errors) {
+                logger.error('Usage flush error', { message });
+            }
+            return {
+                totalRecords: result.totalRecords,
+                reported: result.reported,
+                failed: result.failed,
+                quantityRecorded: result.quantityRecorded,
+                quantityReported: result.quantityReported,
+                errors: result.errors.length,
+                durationMs: Date.now() - startTime,
+            };
+        },
+    });
+}
+//# sourceMappingURL=usage-flush.batch.backend.service.js.map

package/dist/esm/billing/batches/usage-flush.batch.backend.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-flush.batch.backend.service.js","sourceRoot":"","sources":["../../../../src/billing/batches/usage-flush.batch.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,iCAAiC,EAAE,MAAM,4FAA4F,CAAC;AAC/I,OAAO,EAAE,iCAAiC,EAAE,MAAM,gFAAgF,CAAC;AACnI,OAAO,EAAE,kBAAkB,EAAE,MAAM,gDAAgD,CAAC;AAGpF,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAE3C,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,wGAAwG;IACxG,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACrC,yCAAyC;IACzC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,6EAA6E;IAC7E,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,mGAAmG;IACnG,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACnC,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACnC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACpC,CAAC,CAAC;AAEH,MAAM,UAAU,qBAAqB;IACnC,OAAO,iCAAiC,CAAC;QACvC,KAAK,EAAE,qBAAqB;QAC5B,MAAM,EAAE,sBAAsB;QAC9B,oBAAoB,EAAE;YACpB,IAAI,EAAE,iCAAiC,CAAC,IAAI;YAC5C,kBAAkB,EAAE,iCAAiC,CAAC,kBAAkB;YACxE,mBAAmB,EAAE,iCAAiC,CAAC,mBAAmB;YAC1E,iBAAiB,EAAE,iCAAiC,CAAC,cAAc;SACpE;QACD,mBAAmB,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC;YACjC,aAAa,EAAE,GAAG,CAA8B,kBAAkB,CAAC,oBAAoB,CAAC;SACzF,CAAC;QACF,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,EAAE,EAAE;YACnD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAE7B,MAAM,MAAM,GAAG,MAAM,YAAY,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC;YAElE;;;;;;;eAOG;YACH,KAAK,MAAM,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBACpC,MAAM,CAAC,KAAK,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;YACjD,CAAC;YAED,OAAO;gBACL,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;gBACzC,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;gBACzC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM;gBAC5B,UAAU,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;aACnC,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Usage Flush — reports recorded metered usage to the billing provider.\n *\n * ## What this batch is for\n *\n * It is the LAST HOP to money for every METERED product, and until 2026-09-08 it did not exist.\n * `UsageMeteringBackendService.flushToProvider` had no caller anywhere — not in the engine, not in\n * the platform, not in either dogfood application — so a metered product could be declared, priced\n * and synced to the provider while no usage was ever reported (#415). Everything up to the local\n * `usageRecords` row worked; the hop that turns a row into a charge was missing, and the resources\n * registry's own comment already said no cron called it.\n *\n * ## The cadence here is a CEILING, not the interval\n *\n * Each product authors `metering.flushIntervalMinutes`, and the flush decides PER PRODUCT whether\n * enough time has passed since its oldest pending row. This tick only has to be at least as fast as\n * the fastest interval an author can reasonably want; when nothing is due it costs one indexed query\n * per billing scope returning nothing.\n *\n * A slower default would silently cap every product's authored interval at the tick — which is\n * precisely the defect this issue is about: an authored value the runtime quietly overrides.\n *\n * ## Why the run reports quantities and not only rows\n *\n * Getting metering wrong moves money in BOTH directions and neither direction announces itself: an\n * under-report is revenue that never appears, an over-report is a customer charged twice. A count of\n * ROWS can see neither, because rows carry quantities — ten rows reported can be any amount at all.\n * So the output states what was due and what was sent, and a mismatch is raised as an error rather\n * than left as two numbers a reader is expected to compare.\n *\n * ## Failure is per group, and the run keeps going\n *\n * One account's provider failure must not stop every other account's usage from being reported: an\n * unreported row stays selectable by the next run, so continuing costs nothing and stopping costs a\n * whole cycle. The one exception is a pending set so large it trips the drain's runaway guard, where\n * the scope reports NOTHING deliberately — see `listAllUnreportedRecords`.\n *\n * assurance-control: WILDO.BILLING.USAGE_REPORTING — metered usage recorded against an account is\n * reported to the billing provider on a schedule, and each run reconciles what it sent against what\n * was due.\n */\n\nimport { z } from 'zod';\nimport { createCustomBatchExecutionService } from '~wildo-backend-lib/base-classes/services/batches/batches-cronjobs-custom-execution.service';\nimport { ENGINE_USAGE_FLUSH_BATCH_MANIFEST } from '~wildo-backend-lib/base-classes/services/batches/engine-custom-batch-manifests';\nimport { SAAS_SERVICE_TYPES } from '~wildo-backend-lib/inject/models/service-types';\nimport type { UsageMeteringBackendService } from '~wildo-backend-lib/billing/services/back-office/usage-metering.backend.service';\n\nconst UsageFlushInputSchema = z.object({});\n\nconst UsageFlushOutputSchema = z.object({\n  /** Rows that were DUE this run — not rows pending, which is larger while a product is still waiting. */\n  totalRecords: z.number().int().min(0),\n  /** Rows successfully marked reported. */\n  reported: z.number().int().min(0),\n  /** Rows that were not reported, or were reported and could not be marked. */\n  failed: z.number().int().min(0),\n  /** Quantity of usage that was due, and quantity the provider was told about. Meant to be equal. */\n  quantityRecorded: z.number().min(0),\n  quantityReported: z.number().min(0),\n  errors: z.number().int().min(0),\n  durationMs: z.number().int().min(0),\n});\n\nexport function createUsageFlushBatch(): ReturnType<typeof createCustomBatchExecutionService> {\n  return createCustomBatchExecutionService({\n    input: UsageFlushInputSchema,\n    output: UsageFlushOutputSchema,\n    batchCronjob_Context: {\n      kind: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.kind,\n      resourceIdentifier: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.resourceIdentifier,\n      operationIdentifier: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.operationIdentifier,\n      cronJobExpression: ENGINE_USAGE_FLUSH_BATCH_MANIFEST.cronExpression,\n    },\n    resolveDependencies: ({ get }) => ({\n      usageMetering: get<UsageMeteringBackendService>(SAAS_SERVICE_TYPES.UsageMeteringService),\n    }),\n    doHandle: async (_input, { logger, dependencies }) => {\n      const startTime = Date.now();\n\n      const result = await dependencies.usageMetering.flushToProvider();\n\n      /*\n       * Every error is logged individually rather than only counted, because each one names a\n       * specific account and product whose usage did not reach the provider. A count tells an\n       * operator that something is wrong; only the line tells them whose money it is.\n       *\n       * `error` level, not `warn`: unreported usage is revenue that will not be billed unless someone\n       * acts, and the reconciliation line among these is the one that says how much.\n       */\n      for (const message of result.errors) {\n        logger.error('Usage flush error', { message });\n      }\n\n      return {\n        totalRecords: result.totalRecords,\n        reported: result.reported,\n        failed: result.failed,\n        quantityRecorded: result.quantityRecorded,\n        quantityReported: result.quantityReported,\n        errors: result.errors.length,\n        durationMs: Date.now() - startTime,\n      };\n    },\n  });\n}\n"]}

package/dist/esm/billing/models/billing-provider-event-settlement.backend.schemas.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { CoreResourceOperation, type ResourceConfiguration, type ResourceRelationship } from '@wildo-ai/saas-models';
+/**
+ * ============================================================================
+ *  BillingProviderEventSettlement — the DURABLE idempotency ledger for money-affecting
+ *  billing webhook events
+ * ============================================================================
+ *
+ * ## Why a row, when a `Set` was already there
+ *
+ * `BillingWebhookEventRouterBackendService` suppressed duplicate `checkout.session.completed`
+ * deliveries with a process-local `Set` capped at 10 000 entries. Its own comment named the
+ * limitation it could see — "does not protect against retries delivered to different instances" —
+ * and understated it twice over:
+ *
+ *  - **Multi-instance.** Every provider delivers at-least-once. A retry routed to another replica
+ *    finds an empty `Set` and tops the credit pool up a second time.
+ *  - **SINGLE instance.** The LRU eviction means the same replica forgets a session after 10 000
+ *    others, so a late retry double-grants there too. Nothing about the defect needed two
+ *    processes.
+ *  - **Restart.** The `Set` is reconstructed empty on every deploy, and a deploy is the single most
+ *    likely reason a delivery failed and is being retried.
+ *
+ * Money that has already been granted cannot be un-granted by a later correction, so the
+ * suppression has to live where every replica — and every future replica — can see it. That is a
+ * durable row, and the collision has to be a STORE-LEVEL constraint rather than a read-then-write,
+ * because two concurrent deliveries both read "not yet settled" before either writes.
+ *
+ * ## Why the claim is the PRIMARY KEY, and carries no secondary unique index
+ *
+ * `_id` is DERIVED from the claim key ({@link billingProviderEventSettlementId}) rather than minted,
+ * so two deliveries of the same provider event compute the same identity and the second INSERT
+ * collides on the primary key. Both adapters enforce that natively and identically — MongoDB
+ * indexes `_id` implicitly, and the SQL planner emits it as the PRIMARY KEY — so this needs no
+ * `.isUnique()` field beside it, and there is no second constraint that could be planned on one
+ * adapter and not the other.
+ *
+ * The digest is 24 hexadecimal characters because that is the ONE identity shape both adapters
+ * accept: the zod→mongoose convertor types a top-level `_id` as `Schema.Types.ObjectId`
+ * unconditionally (a UUID there produces a row Mongoose cannot hydrate — measured on consumable
+ * tokens), while the SQL planner types `_id` as a plain text column. A truncated SHA-256 satisfies
+ * both.
+ *
+ * ## What the row does NOT do
+ *
+ * It is not a webhook audit log. It records only what a second delivery must be able to ask —
+ * *has this already been applied, and if not, is somebody applying it right now?* — plus the
+ * `claimKey` in readable form so an operator reading the table can tell which provider event a row
+ * belongs to without reversing a digest.
+ *
+ * REPOSITORY_ONLY on every operation, like its `DataSeedRun` and `ExternalDataPipelineState`
+ * siblings: the webhook router is the only writer and there is no reader outside the engine.
+ */
+export declare const BillingProviderEventSettlementSchema: z.ZodObject<{
+    _id: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    claimKey: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    eventType: z.ZodString;
+    claimedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
+    appliedAt: z.ZodOptional<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
+}, z.core.$strip>;
+export type BillingProviderEventSettlement = z.infer<typeof BillingProviderEventSettlementSchema>;
+/**
+ * How long a claim may be held before another delivery of the same event may take it over.
+ *
+ * The window exists for exactly one failure: a handler claims, then the process dies before the
+ * grant lands. Without a takeover the credit would be lost forever — the row says "claimed" and
+ * nothing would ever apply it.
+ *
+ * Fifteen minutes is chosen against the RETRY CADENCE, not against the handler's duration. The
+ * handler takes milliseconds, so any value above a few seconds covers the honest in-flight case;
+ * what matters at the other end is that the window is comfortably shorter than the interval at
+ * which a provider re-delivers a failed event (Stripe backs off to hours over its three-day retry
+ * schedule), or the takeover would never get its turn.
+ */
+export declare const BILLING_PROVIDER_EVENT_SETTLEMENT_CLAIM_LEASE_MS: number;
+/**
+ * Derive the durable claim identity for one provider event.
+ *
+ * SHA-256 truncated to 24 hex characters — see the schema header for why that shape and not a UUID.
+ * The truncation leaves 96 bits, so a collision between two DIFFERENT provider events would need
+ * on the order of 2^48 of them; a collision would suppress a legitimate grant, which is why the
+ * bound is stated rather than assumed.
+ */
+export declare function billingProviderEventSettlementId(claimKey: string): string;
+export declare enum BillingProviderEventSettlementVariantKey {
+    INTERNAL = "internal"
+}
+type BillingProviderEventSettlement_CoreOperations = CoreResourceOperation.READ | CoreResourceOperation.CREATE | CoreResourceOperation.UPDATE;
+export declare const billingProviderEventSettlementResourceConfiguration_InitializationFactory: (resourcesRelationships: ResourceRelationship[]) => ResourceConfiguration<undefined, BillingProviderEventSettlement_CoreOperations, typeof BillingProviderEventSettlementSchema>;
+export {};
+//# sourceMappingURL=billing-provider-event-settlement.backend.schemas.d.ts.map

package/dist/esm/billing/models/billing-provider-event-settlement.backend.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing-provider-event-settlement.backend.schemas.d.ts","sourceRoot":"","sources":["../../../../src/billing/models/billing-provider-event-settlement.backend.schemas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAEL,qBAAqB,EAIrB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EAC1B,MAAM,uBAAuB,CAAC;AAc/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,oCAAoC;;;;;;iBAoC/C,CAAC;AAEH,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAC;AAElG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gDAAgD,QAAiB,CAAC;AAE/E;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,oBAAY,wCAAwC;IAClD,QAAQ,aAAa;CACtB;AAED,KAAK,6CAA6C,GAC9C,qBAAqB,CAAC,IAAI,GAC1B,qBAAqB,CAAC,MAAM,GAC5B,qBAAqB,CAAC,MAAM,CAAC;AAWjC,eAAO,MAAM,yEAAyE,GACpF,wBAAwB,oBAAoB,EAAE,KAC7C,qBAAqB,CAAC,SAAS,EAAE,6CAA6C,EAAE,OAAO,oCAAoC,CAwB7H,CAAC"}

package/dist/esm/billing/models/billing-provider-event-settlement.backend.schemas.js

@@ -0,0 +1,152 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { CORE_APP_ROLES, CoreResourceOperation, createResourceConfiguration_Initialization, ResourceOperationRiskLevel, ResourceOperationVariantType, } from '@wildo-ai/saas-models';
+/*
+ * entrypoint-closure-waiver: the same crossing (and the same measured result) as
+ * `external-data-pipeline-state.backend.schemas` — `resources-types.backend.schemas` is published
+ * only by the `./backend-resource-registry` subpath, but no root-exported contract of this module
+ * INFERS a type from it: the factory's return type is annotated explicitly and
+ * `BillingProviderEventSettlement` is a structural `z.infer`.
+ */
+import { BackendResourceFieldIdentifier, BackendResourceType, } from '../../resources/models/resources-types.backend.schemas.js';
+/**
+ * ============================================================================
+ *  BillingProviderEventSettlement — the DURABLE idempotency ledger for money-affecting
+ *  billing webhook events
+ * ============================================================================
+ *
+ * ## Why a row, when a `Set` was already there
+ *
+ * `BillingWebhookEventRouterBackendService` suppressed duplicate `checkout.session.completed`
+ * deliveries with a process-local `Set` capped at 10 000 entries. Its own comment named the
+ * limitation it could see — "does not protect against retries delivered to different instances" —
+ * and understated it twice over:
+ *
+ *  - **Multi-instance.** Every provider delivers at-least-once. A retry routed to another replica
+ *    finds an empty `Set` and tops the credit pool up a second time.
+ *  - **SINGLE instance.** The LRU eviction means the same replica forgets a session after 10 000
+ *    others, so a late retry double-grants there too. Nothing about the defect needed two
+ *    processes.
+ *  - **Restart.** The `Set` is reconstructed empty on every deploy, and a deploy is the single most
+ *    likely reason a delivery failed and is being retried.
+ *
+ * Money that has already been granted cannot be un-granted by a later correction, so the
+ * suppression has to live where every replica — and every future replica — can see it. That is a
+ * durable row, and the collision has to be a STORE-LEVEL constraint rather than a read-then-write,
+ * because two concurrent deliveries both read "not yet settled" before either writes.
+ *
+ * ## Why the claim is the PRIMARY KEY, and carries no secondary unique index
+ *
+ * `_id` is DERIVED from the claim key ({@link billingProviderEventSettlementId}) rather than minted,
+ * so two deliveries of the same provider event compute the same identity and the second INSERT
+ * collides on the primary key. Both adapters enforce that natively and identically — MongoDB
+ * indexes `_id` implicitly, and the SQL planner emits it as the PRIMARY KEY — so this needs no
+ * `.isUnique()` field beside it, and there is no second constraint that could be planned on one
+ * adapter and not the other.
+ *
+ * The digest is 24 hexadecimal characters because that is the ONE identity shape both adapters
+ * accept: the zod→mongoose convertor types a top-level `_id` as `Schema.Types.ObjectId`
+ * unconditionally (a UUID there produces a row Mongoose cannot hydrate — measured on consumable
+ * tokens), while the SQL planner types `_id` as a plain text column. A truncated SHA-256 satisfies
+ * both.
+ *
+ * ## What the row does NOT do
+ *
+ * It is not a webhook audit log. It records only what a second delivery must be able to ask —
+ * *has this already been applied, and if not, is somebody applying it right now?* — plus the
+ * `claimKey` in readable form so an operator reading the table can tell which provider event a row
+ * belongs to without reversing a digest.
+ *
+ * REPOSITORY_ONLY on every operation, like its `DataSeedRun` and `ExternalDataPipelineState`
+ * siblings: the webhook router is the only writer and there is no reader outside the engine.
+ */
+export const BillingProviderEventSettlementSchema = z.object({
+    /**
+     * The claim itself, derived from `claimKey` — see the header for why the identity rather than a
+     * secondary unique field carries it.
+     */
+    _id: z.string().min(1).isPrimaryKey(),
+    /**
+     * The claim key in readable form: `<eventType>:<checkout session id or provider event id>`.
+     *
+     * Stored ALONGSIDE the digest it produced, not instead of it. A digest is unreadable, and an
+     * operator asking "did we settle session cs_live_…?" needs a column to filter on; a second unique
+     * constraint here would be a second thing that must agree with the primary key for no gain, so
+     * this is indexed and NOT unique.
+     */
+    claimKey: z.string().min(1).isDBIndexed(),
+    /** The provider event type the claim was taken for — `checkout.session.completed` today. */
+    eventType: z.string().min(1),
+    /**
+     * When a handler took the claim. Refreshed when a STALE claim is taken over, which is what makes
+     * this the lease timestamp rather than a creation timestamp.
+     */
+    claimedAt: z.date().isDBIndexed(),
+    /**
+     * Set once the money-affecting work COMPLETED. Absent while a handler holds the claim.
+     *
+     * The distinction is the whole reason the row has two timestamps: a claim with no `appliedAt` is
+     * either in flight or was abandoned by a process that died, and only the second case may be
+     * re-taken. `{ $exists: false }` is the one presence predicate both adapters answer identically
+     * (MongoDB: absent path; PostgreSQL: `IS NULL`), which is why the state is expressed as the
+     * absence of a value rather than as a status enum that would need its own vocabulary.
+     */
+    appliedAt: z.date().isDBIndexed().optional(),
+});
+/**
+ * How long a claim may be held before another delivery of the same event may take it over.
+ *
+ * The window exists for exactly one failure: a handler claims, then the process dies before the
+ * grant lands. Without a takeover the credit would be lost forever — the row says "claimed" and
+ * nothing would ever apply it.
+ *
+ * Fifteen minutes is chosen against the RETRY CADENCE, not against the handler's duration. The
+ * handler takes milliseconds, so any value above a few seconds covers the honest in-flight case;
+ * what matters at the other end is that the window is comfortably shorter than the interval at
+ * which a provider re-delivers a failed event (Stripe backs off to hours over its three-day retry
+ * schedule), or the takeover would never get its turn.
+ */
+export const BILLING_PROVIDER_EVENT_SETTLEMENT_CLAIM_LEASE_MS = 15 * 60 * 1000;
+/**
+ * Derive the durable claim identity for one provider event.
+ *
+ * SHA-256 truncated to 24 hex characters — see the schema header for why that shape and not a UUID.
+ * The truncation leaves 96 bits, so a collision between two DIFFERENT provider events would need
+ * on the order of 2^48 of them; a collision would suppress a legitimate grant, which is why the
+ * bound is stated rather than assumed.
+ */
+export function billingProviderEventSettlementId(claimKey) {
+    return createHash('sha256').update(claimKey).digest('hex').slice(0, 24);
+}
+export var BillingProviderEventSettlementVariantKey;
+(function (BillingProviderEventSettlementVariantKey) {
+    BillingProviderEventSettlementVariantKey["INTERNAL"] = "internal";
+})(BillingProviderEventSettlementVariantKey || (BillingProviderEventSettlementVariantKey = {}));
+const internalVariant = () => ({
+    variantKey: BillingProviderEventSettlementVariantKey.INTERNAL,
+    // The literal annotation keeps the variant inside the discriminated builder union.
+    variantType: ResourceOperationVariantType.REPOSITORY_ONLY,
+    isDefault: true,
+    roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],
+    riskLevel: ResourceOperationRiskLevel.LOW,
+});
+export const billingProviderEventSettlementResourceConfiguration_InitializationFactory = (resourcesRelationships) => {
+    return createResourceConfiguration_Initialization({
+        mainSchema: BillingProviderEventSettlementSchema,
+        resourceIdentifier: BackendResourceType.BILLING_PROVIDER_EVENT_SETTLEMENTS,
+        resourceFieldIdentifier: BackendResourceFieldIdentifier[BackendResourceType.BILLING_PROVIDER_EVENT_SETTLEMENTS],
+        resourceRelationships: resourcesRelationships,
+        isSystemResource: true,
+        coreOperations: [
+            CoreResourceOperation.READ,
+            CoreResourceOperation.CREATE,
+            CoreResourceOperation.UPDATE,
+        ],
+        operationsConfiguration: {
+            [CoreResourceOperation.READ]: { variants: [internalVariant()] },
+            [CoreResourceOperation.CREATE]: { variants: [internalVariant()] },
+            [CoreResourceOperation.UPDATE]: { variants: [internalVariant()] },
+        },
+    });
+};
+//# sourceMappingURL=billing-provider-event-settlement.backend.schemas.js.map

package/dist/esm/billing/models/billing-provider-event-settlement.backend.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"billing-provider-event-settlement.backend.schemas.js","sourceRoot":"","sources":["../../../../src/billing/models/billing-provider-event-settlement.backend.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,0CAA0C,EAC1C,0BAA0B,EAC1B,4BAA4B,GAG7B,MAAM,uBAAuB,CAAC;AAE/B;;;;;;GAMG;AACH,OAAO,EACL,8BAA8B,EAC9B,mBAAmB,GACpB,MAAM,wDAAwD,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3D;;;OAGG;IACH,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE;IAErC;;;;;;;OAOG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;IAEzC,4FAA4F;IAC5F,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAE5B;;;OAGG;IACH,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE;IAEjC;;;;;;;;OAQG;IACH,SAAS,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE;CAC7C,CAAC,CAAC;AAIH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,gDAAgD,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAE/E;;;;;;;GAOG;AACH,MAAM,UAAU,gCAAgC,CAAC,QAAgB;IAC/D,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED,MAAM,CAAN,IAAY,wCAEX;AAFD,WAAY,wCAAwC;IAClD,iEAAqB,CAAA;AACvB,CAAC,EAFW,wCAAwC,KAAxC,wCAAwC,QAEnD;AAOD,MAAM,eAAe,GAAG,GAAG,EAAE,CAAC,CAAC;IAC7B,UAAU,EAAE,wCAAwC,CAAC,QAAQ;IAC7D,mFAAmF;IACnF,WAAW,EAAE,4BAA4B,CAAC,eAA+D;IACzG,SAAS,EAAE,IAAI;IACf,KAAK,EAAE,CAAC,cAAc,CAAC,qBAAqB,CAAC;IAC7C,SAAS,EAAE,0BAA0B,CAAC,GAAG;CAC1C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yEAAyE,GAAG,CACvF,sBAA8C,EACgF,EAAE;IAChI,OAAO,0CAA0C,CAI/C;QACA,UAAU,EAAE,oCAAoC;QAChD,kBAAkB,EAAE,mBAAmB,CAAC,kCAAkC;QAC1E,uBAAuB,EAAE,8BAA8B,CAAC,mBAAmB,CAAC,kCAAkC,CAAC;QAC/G,qBAAqB,EAAE,sBAAsB;QAC7C,gBAAgB,EAAE,IAAI;QAEtB,cAAc,EAAE;YACd,qBAAqB,CAAC,IAAI;YAC1B,qBAAqB,CAAC,MAAM;YAC5B,qBAAqB,CAAC,MAAM;SAC7B;QAED,uBAAuB,EAAE;YACvB,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,eAAe,EAAE,CAAC,EAAE;YAC/D,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,eAAe,EAAE,CAAC,EAAE;YACjE,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,eAAe,EAAE,CAAC,EAAE;SAClE;KACF,CAAC,CAAC;AACL,CAAC,CAAC","sourcesContent":["import { createHash } from 'node:crypto';\nimport { z } from 'zod';\n\nimport {\n  CORE_APP_ROLES,\n  CoreResourceOperation,\n  createResourceConfiguration_Initialization,\n  ResourceOperationRiskLevel,\n  ResourceOperationVariantType,\n  type ResourceConfiguration,\n  type ResourceRelationship,\n} from '@wildo-ai/saas-models';\n\n/*\n * entrypoint-closure-waiver: the same crossing (and the same measured result) as\n * `external-data-pipeline-state.backend.schemas` — `resources-types.backend.schemas` is published\n * only by the `./backend-resource-registry` subpath, but no root-exported contract of this module\n * INFERS a type from it: the factory's return type is annotated explicitly and\n * `BillingProviderEventSettlement` is a structural `z.infer`.\n */\nimport {\n  BackendResourceFieldIdentifier,\n  BackendResourceType,\n} from '../../resources/models/resources-types.backend.schemas';\n\n/**\n * ============================================================================\n *  BillingProviderEventSettlement — the DURABLE idempotency ledger for money-affecting\n *  billing webhook events\n * ============================================================================\n *\n * ## Why a row, when a `Set` was already there\n *\n * `BillingWebhookEventRouterBackendService` suppressed duplicate `checkout.session.completed`\n * deliveries with a process-local `Set` capped at 10 000 entries. Its own comment named the\n * limitation it could see — \"does not protect against retries delivered to different instances\" —\n * and understated it twice over:\n *\n *  - **Multi-instance.** Every provider delivers at-least-once. A retry routed to another replica\n *    finds an empty `Set` and tops the credit pool up a second time.\n *  - **SINGLE instance.** The LRU eviction means the same replica forgets a session after 10 000\n *    others, so a late retry double-grants there too. Nothing about the defect needed two\n *    processes.\n *  - **Restart.** The `Set` is reconstructed empty on every deploy, and a deploy is the single most\n *    likely reason a delivery failed and is being retried.\n *\n * Money that has already been granted cannot be un-granted by a later correction, so the\n * suppression has to live where every replica — and every future replica — can see it. That is a\n * durable row, and the collision has to be a STORE-LEVEL constraint rather than a read-then-write,\n * because two concurrent deliveries both read \"not yet settled\" before either writes.\n *\n * ## Why the claim is the PRIMARY KEY, and carries no secondary unique index\n *\n * `_id` is DERIVED from the claim key ({@link billingProviderEventSettlementId}) rather than minted,\n * so two deliveries of the same provider event compute the same identity and the second INSERT\n * collides on the primary key. Both adapters enforce that natively and identically — MongoDB\n * indexes `_id` implicitly, and the SQL planner emits it as the PRIMARY KEY — so this needs no\n * `.isUnique()` field beside it, and there is no second constraint that could be planned on one\n * adapter and not the other.\n *\n * The digest is 24 hexadecimal characters because that is the ONE identity shape both adapters\n * accept: the zod→mongoose convertor types a top-level `_id` as `Schema.Types.ObjectId`\n * unconditionally (a UUID there produces a row Mongoose cannot hydrate — measured on consumable\n * tokens), while the SQL planner types `_id` as a plain text column. A truncated SHA-256 satisfies\n * both.\n *\n * ## What the row does NOT do\n *\n * It is not a webhook audit log. It records only what a second delivery must be able to ask —\n * *has this already been applied, and if not, is somebody applying it right now?* — plus the\n * `claimKey` in readable form so an operator reading the table can tell which provider event a row\n * belongs to without reversing a digest.\n *\n * REPOSITORY_ONLY on every operation, like its `DataSeedRun` and `ExternalDataPipelineState`\n * siblings: the webhook router is the only writer and there is no reader outside the engine.\n */\nexport const BillingProviderEventSettlementSchema = z.object({\n  /**\n   * The claim itself, derived from `claimKey` — see the header for why the identity rather than a\n   * secondary unique field carries it.\n   */\n  _id: z.string().min(1).isPrimaryKey(),\n\n  /**\n   * The claim key in readable form: `<eventType>:<checkout session id or provider event id>`.\n   *\n   * Stored ALONGSIDE the digest it produced, not instead of it. A digest is unreadable, and an\n   * operator asking \"did we settle session cs_live_…?\" needs a column to filter on; a second unique\n   * constraint here would be a second thing that must agree with the primary key for no gain, so\n   * this is indexed and NOT unique.\n   */\n  claimKey: z.string().min(1).isDBIndexed(),\n\n  /** The provider event type the claim was taken for — `checkout.session.completed` today. */\n  eventType: z.string().min(1),\n\n  /**\n   * When a handler took the claim. Refreshed when a STALE claim is taken over, which is what makes\n   * this the lease timestamp rather than a creation timestamp.\n   */\n  claimedAt: z.date().isDBIndexed(),\n\n  /**\n   * Set once the money-affecting work COMPLETED. Absent while a handler holds the claim.\n   *\n   * The distinction is the whole reason the row has two timestamps: a claim with no `appliedAt` is\n   * either in flight or was abandoned by a process that died, and only the second case may be\n   * re-taken. `{ $exists: false }` is the one presence predicate both adapters answer identically\n   * (MongoDB: absent path; PostgreSQL: `IS NULL`), which is why the state is expressed as the\n   * absence of a value rather than as a status enum that would need its own vocabulary.\n   */\n  appliedAt: z.date().isDBIndexed().optional(),\n});\n\nexport type BillingProviderEventSettlement = z.infer<typeof BillingProviderEventSettlementSchema>;\n\n/**\n * How long a claim may be held before another delivery of the same event may take it over.\n *\n * The window exists for exactly one failure: a handler claims, then the process dies before the\n * grant lands. Without a takeover the credit would be lost forever — the row says \"claimed\" and\n * nothing would ever apply it.\n *\n * Fifteen minutes is chosen against the RETRY CADENCE, not against the handler's duration. The\n * handler takes milliseconds, so any value above a few seconds covers the honest in-flight case;\n * what matters at the other end is that the window is comfortably shorter than the interval at\n * which a provider re-delivers a failed event (Stripe backs off to hours over its three-day retry\n * schedule), or the takeover would never get its turn.\n */\nexport const BILLING_PROVIDER_EVENT_SETTLEMENT_CLAIM_LEASE_MS = 15 * 60 * 1000;\n\n/**\n * Derive the durable claim identity for one provider event.\n *\n * SHA-256 truncated to 24 hex characters — see the schema header for why that shape and not a UUID.\n * The truncation leaves 96 bits, so a collision between two DIFFERENT provider events would need\n * on the order of 2^48 of them; a collision would suppress a legitimate grant, which is why the\n * bound is stated rather than assumed.\n */\nexport function billingProviderEventSettlementId(claimKey: string): string {\n  return createHash('sha256').update(claimKey).digest('hex').slice(0, 24);\n}\n\nexport enum BillingProviderEventSettlementVariantKey {\n  INTERNAL = 'internal',\n}\n\ntype BillingProviderEventSettlement_CoreOperations =\n  | CoreResourceOperation.READ\n  | CoreResourceOperation.CREATE\n  | CoreResourceOperation.UPDATE;\n\nconst internalVariant = () => ({\n  variantKey: BillingProviderEventSettlementVariantKey.INTERNAL,\n  // The literal annotation keeps the variant inside the discriminated builder union.\n  variantType: ResourceOperationVariantType.REPOSITORY_ONLY as ResourceOperationVariantType.REPOSITORY_ONLY,\n  isDefault: true,\n  roles: [CORE_APP_ROLES.APP_ADMIN_SUPER_ADMIN],\n  riskLevel: ResourceOperationRiskLevel.LOW,\n});\n\nexport const billingProviderEventSettlementResourceConfiguration_InitializationFactory = (\n  resourcesRelationships: ResourceRelationship[],\n): ResourceConfiguration<undefined, BillingProviderEventSettlement_CoreOperations, typeof BillingProviderEventSettlementSchema> => {\n  return createResourceConfiguration_Initialization<\n    undefined,\n    BillingProviderEventSettlement_CoreOperations,\n    typeof BillingProviderEventSettlementSchema\n  >({\n    mainSchema: BillingProviderEventSettlementSchema,\n    resourceIdentifier: BackendResourceType.BILLING_PROVIDER_EVENT_SETTLEMENTS,\n    resourceFieldIdentifier: BackendResourceFieldIdentifier[BackendResourceType.BILLING_PROVIDER_EVENT_SETTLEMENTS],\n    resourceRelationships: resourcesRelationships,\n    isSystemResource: true,\n\n    coreOperations: [\n      CoreResourceOperation.READ,\n      CoreResourceOperation.CREATE,\n      CoreResourceOperation.UPDATE,\n    ],\n\n    operationsConfiguration: {\n      [CoreResourceOperation.READ]: { variants: [internalVariant()] },\n      [CoreResourceOperation.CREATE]: { variants: [internalVariant()] },\n      [CoreResourceOperation.UPDATE]: { variants: [internalVariant()] },\n    },\n  });\n};\n"]}

package/dist/esm/billing/services/back-office/abstract-billing.backend.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abstract-billing.backend.service.d.ts","sourceRoot":"","sources":["../../../../../../src/billing/services/back-office/abstract-billing.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EAItB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAClG,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,6FAA6F,CAAC;AACzJ,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,+EAA+E,CAAC;AAC3I,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAChI,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qEAAqE,CAAC;AAC5G,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kEAAkE,CAAC;AAEnH,8BACsB,6BAA6B;IAQZ,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa;IAChB,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,qCAAqC;IACnE,SAAS,CAAC,QAAQ,CAAC,uBAAuB,EAAE,qCAAqC;IAC/F,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,+BAA+B;IACzE,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,0BAA0B;IAX7G,SAAS,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAEjF,sEAAsE;IACtE,SAAS,CAAC,eAAe,EAAE,yBAAyB,GAAG,IAAI,CAAQ;IACnE,SAAS,CAAC,aAAa,UAAS;gBAGwB,MAAM,EAAE,aAAa,EACG,gBAAgB,EAAE,qCAAqC,EAChD,uBAAuB,EAAE,qCAAqC,EAC5E,iBAAiB,EAAE,+BAA+B,EACtD,YAAY,EAAE,0BAA0B;IAW7G;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,IAAI;IAKvE,SAAS,CAAC,iBAAiB,IAAI,IAAI;IAanC;;;;;;;;;;;;;;;;;;;;OAoBG;cACa,WAAW,CAAC,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAW7H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,SAAS,CAAC,gBAAgB,CACxB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,QAAQ,GAAE,MAAM,GAAG,OAAgB,GAClC,IAAI;CAsBR"}
+{"version":3,"file":"abstract-billing.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/billing/services/back-office/abstract-billing.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EAItB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAClG,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,6FAA6F,CAAC;AACzJ,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,+EAA+E,CAAC;AAC3I,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAChI,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qEAAqE,CAAC;AAC5G,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kEAAkE,CAAC;AAEnH,8BACsB,6BAA6B;IAQZ,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa;IAChB,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,qCAAqC;IACnE,SAAS,CAAC,QAAQ,CAAC,uBAAuB,EAAE,qCAAqC;IAC/F,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,+BAA+B;IACzE,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,0BAA0B;IAX7G,SAAS,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAEjF,sEAAsE;IACtE,SAAS,CAAC,eAAe,EAAE,yBAAyB,GAAG,IAAI,CAAQ;IACnE,SAAS,CAAC,aAAa,UAAS;gBAGwB,MAAM,EAAE,aAAa,EACG,gBAAgB,EAAE,qCAAqC,EAChD,uBAAuB,EAAE,qCAAqC,EAC5E,iBAAiB,EAAE,+BAA+B,EACtD,YAAY,EAAE,0BAA0B;IAW7G;;;;OAIG;IACH,SAAS,CAAC,kBAAkB,CAAC,QAAQ,EAAE,yBAAyB,GAAG,IAAI;IAKvE,SAAS,CAAC,iBAAiB,IAAI,IAAI;IAanC;;;;;;;;;;;;;;;;;;;;OAoBG;cACa,WAAW,CAAC,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IAW7H;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,SAAS,CAAC,gBAAgB,CACxB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,QAAQ,GAAE,MAAM,GAAG,OAAgB,GAClC,IAAI;CAsBR"}

package/dist/esm/billing/services/back-office/billing-feature-sync.backend.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"billing-feature-sync.backend.service.d.ts","sourceRoot":"","sources":["../../../../../../src/billing/services/back-office/billing-feature-sync.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAIL,KAAK,aAAa,EAYnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAClG,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,6FAA6F,CAAC;AACzJ,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,+EAA+E,CAAC;AAC3I,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAChI,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kEAAkE,CAAC;AACnH,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,qGAAqG,CAAC;AACrK,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AACxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uDAAuD,CAAC;AAC9F,OAAO,EAAE,6BAA6B,EAAE,MAAM,kFAAkF,CAAC;AAEjI,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,kFAAkF,CAAC;AAChJ,OAAO,EAAE,KAAK,uBAAuB,EAA6B,MAAM,mFAAmF,CAAC;AAU5J,qBACa,gCAAiC,SAAQ,6BAA6B;IAOhB,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IAC3D,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY;IACzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjB,OAAO,CAAC,QAAQ,CAAC,eAAe;gBAR1D,MAAM,EAAE,aAAa,EACG,gBAAgB,EAAE,qCAAqC,EAChD,uBAAuB,EAAE,qCAAqC,EAC5E,iBAAiB,EAAE,+BAA+B,EACtD,YAAY,EAAE,0BAA0B,EACR,oBAAoB,EAAE,yCAAyC,EACnF,YAAY,EAAE,YAAY,EACxB,gBAAgB,EAAE,gBAAgB,EAClB,eAAe,EAAE,uCAAuC;IASxI;;;;;;;;;;;;OAYG;IACU,qBAAqB,CAAC,gBAAgB,EAAE,MAAM,EAAE,cAAc,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCpH;;;OAGG;IACU,6BAA6B,CACxC,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,EACxB,qBAAqB,EAAE,MAAM,GAC5B,OAAO,CAAC,aAAa,CAAC;IA6BzB;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAyD7F;;;;;;;;OAQG;IACH,OAAO,CAAC,wBAAwB;IAgEhC;;;;;;;OAOG;YACW,2BAA2B;IA0DzC;;OAEG;YACW,sBAAsB;IAcpC;;;OAGG;YACW,wBAAwB;YAoCxB,iBAAiB;YAcjB,sBAAsB;YAiBtB,UAAU;IAgBxB;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAOpC;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAGhC"}
+{"version":3,"file":"billing-feature-sync.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/billing/services/back-office/billing-feature-sync.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAIL,KAAK,aAAa,EAYnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8DAA8D,CAAC;AAClG,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,6FAA6F,CAAC;AACzJ,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,+EAA+E,CAAC;AAC3I,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAChI,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kEAAkE,CAAC;AACnH,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,qGAAqG,CAAC;AACrK,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qDAAqD,CAAC;AACxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uDAAuD,CAAC;AAC9F,OAAO,EAAE,6BAA6B,EAAE,MAAM,kFAAkF,CAAC;AAEjI,OAAO,KAAK,EAAE,uCAAuC,EAAE,MAAM,kFAAkF,CAAC;AAChJ,OAAO,EAAE,KAAK,uBAAuB,EAA6B,MAAM,mFAAmF,CAAC;AAU5J,qBACa,gCAAiC,SAAQ,6BAA6B;IAOhB,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IAC3D,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY;IACzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjB,OAAO,CAAC,QAAQ,CAAC,eAAe;gBAR1D,MAAM,EAAE,aAAa,EACG,gBAAgB,EAAE,qCAAqC,EAChD,uBAAuB,EAAE,qCAAqC,EAC5E,iBAAiB,EAAE,+BAA+B,EACtD,YAAY,EAAE,0BAA0B,EACR,oBAAoB,EAAE,yCAAyC,EACnF,YAAY,EAAE,YAAY,EACxB,gBAAgB,EAAE,gBAAgB,EAClB,eAAe,EAAE,uCAAuC;IASxI;;;;;;;;;;;;OAYG;IACU,qBAAqB,CAAC,gBAAgB,EAAE,MAAM,EAAE,cAAc,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCpH;;;OAGG;IACU,6BAA6B,CACxC,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,EACxB,qBAAqB,EAAE,MAAM,GAC5B,OAAO,CAAC,aAAa,CAAC;IA6BzB;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC;QAAE,iBAAiB,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAyD7F;;;;;;;;OAQG;IACH,OAAO,CAAC,wBAAwB;IAgEhC;;;;;;;OAOG;YACW,2BAA2B;IA0DzC;;OAEG;YACW,sBAAsB;IAcpC;;;OAGG;YACW,wBAAwB;YAoCxB,iBAAiB;YAcjB,sBAAsB;YAiBtB,UAAU;IAgBxB;;OAEG;IACH,OAAO,CAAC,4BAA4B;IAOpC;;OAEG;IACH,OAAO,CAAC,uBAAuB;CAGhC"}