@arcblock/payment-service 1.29.1 → 1.29.3-beta-frontend-serve.4

package/dist/drivers.js

@@ -339,6 +339,84 @@ var init_queue = __esm({
   }
 });
 
+// ../../blocklets/core/api/src/libs/env.ts
+function readConfig(key) {
+  const injected = activeConfig?.[key];
+  if (injected !== void 0 && injected !== null) return String(injected);
+  const fromEnv = process.env[key];
+  return fromEnv === void 0 ? void 0 : fromEnv;
+}
+var import_env, activeConfig, tenantModeRaw, blockletAppPid, env_default;
+var init_env = __esm({
+  "../../blocklets/core/api/src/libs/env.ts"() {
+    "use strict";
+    import_env = require("@blocklet/sdk/lib/env");
+    tenantModeRaw = () => readConfig("PAYMENT_TENANT_MODE");
+    blockletAppPid = () => readConfig("BLOCKLET_APP_PID");
+    env_default = {
+      ...import_env.env
+    };
+  }
+});
+
+// ../../blocklets/core/api/src/libs/tenant.ts
+var tenant_exports = {};
+__export(tenant_exports, {
+  INVALID_TENANT_TABLE: () => INVALID_TENANT_TABLE,
+  TENANT_CONTEXT_MISSING: () => TENANT_CONTEXT_MISSING,
+  TENANT_HOST_UNRESOLVED: () => TENANT_HOST_UNRESOLVED,
+  TENANT_MISMATCH: () => TENANT_MISMATCH,
+  TenantError: () => TenantError,
+  assertValidInstanceDid: () => assertValidInstanceDid,
+  getDefaultInstanceDid: () => getDefaultInstanceDid,
+  getTenantMode: () => getTenantMode,
+  resolveRowTenant: () => resolveRowTenant,
+  setDefaultInstanceDid: () => setDefaultInstanceDid
+});
+function getTenantMode() {
+  return tenantModeRaw() === "multi" ? "multi" : "single";
+}
+function setDefaultInstanceDid(did) {
+  if (did !== void 0) assertValidInstanceDid(did);
+  overrideDefaultInstanceDid = did;
+}
+function getDefaultInstanceDid() {
+  const did = overrideDefaultInstanceDid || blockletAppPid() || "";
+  if (!did) {
+    throw new TenantError(TENANT_CONTEXT_MISSING, "app DID is not configured for this deployment");
+  }
+  return did;
+}
+function resolveRowTenant(row) {
+  const fromRow = row?.instance_did;
+  if (fromRow) return fromRow;
+  if (getTenantMode() === "single") return getDefaultInstanceDid();
+  throw new TenantError(TENANT_CONTEXT_MISSING, "row has no tenant and deployment is in multi mode");
+}
+function assertValidInstanceDid(instanceDid) {
+  if (typeof instanceDid !== "string" || !/^\S{3,}$/.test(instanceDid)) {
+    throw new TenantError(TENANT_CONTEXT_MISSING, `invalid instanceDid: ${JSON.stringify(instanceDid)}`);
+  }
+}
+var TENANT_CONTEXT_MISSING, TENANT_MISMATCH, INVALID_TENANT_TABLE, TENANT_HOST_UNRESOLVED, TenantError, overrideDefaultInstanceDid;
+var init_tenant = __esm({
+  "../../blocklets/core/api/src/libs/tenant.ts"() {
+    "use strict";
+    init_env();
+    TENANT_CONTEXT_MISSING = "TENANT_CONTEXT_MISSING";
+    TENANT_MISMATCH = "TENANT_MISMATCH";
+    INVALID_TENANT_TABLE = "INVALID_TENANT_TABLE";
+    TENANT_HOST_UNRESOLVED = "TENANT_HOST_UNRESOLVED";
+    TenantError = class extends Error {
+      constructor(code, message) {
+        super(message);
+        this.name = "TenantError";
+        this.code = code;
+      }
+    };
+  }
+});
+
 // ../../blocklets/core/api/src/libs/drivers/cron.ts
 function parseField(field, min, max) {
   if (field === "*") return null;
@@ -387,6 +465,37 @@ function shouldRunInWindow(cronExpr, date) {
 function createCronRegistry(kind) {
   const jobs = [];
   let onErrorHandler;
+  const selfSchedule = kind === "node-cron";
+  let scheduler = null;
+  const stopScheduler = () => {
+    if (!scheduler) return;
+    for (const job of Object.values(scheduler.jobs)) {
+      try {
+        job.stop();
+      } catch {
+      }
+    }
+    scheduler = null;
+  };
+  const startScheduler = () => {
+    stopScheduler();
+    if (!selfSchedule || jobs.length === 0) return;
+    const mod = require("@abtnode/cron");
+    const init = mod.init ?? mod.default?.init;
+    const { getTenantMode: getTenantMode2 } = (init_tenant(), __toCommonJS(tenant_exports));
+    const isMulti = getTenantMode2() === "multi";
+    scheduler = init({
+      context: {},
+      jobs: jobs.map((j) => ({
+        name: j.name,
+        time: j.time,
+        fn: j.fn,
+        options: isMulti ? { ...j.options || {}, runOnInit: false } : j.options || {}
+      })),
+      onError: onErrorHandler ?? (() => {
+      })
+    });
+  };
   return {
     kind,
     register(next, onError) {
@@ -395,9 +504,24 @@ function createCronRegistry(kind) {
       for (const job of next || []) {
         if (job.name && job.time && typeof job.fn === "function") jobs.push(job);
       }
+      startScheduler();
     },
     addJob(name, time, fn, options) {
       jobs.push({ name, time, fn, options });
+      if (selfSchedule && scheduler) {
+        try {
+          scheduler.addJob(name, time, fn, options || {});
+        } catch (err) {
+          onErrorHandler?.(err, name);
+        }
+      }
+    },
+    stop() {
+      stopScheduler();
+    },
+    dispose() {
+      stopScheduler();
+      jobs.length = 0;
     },
     async runDue(now = /* @__PURE__ */ new Date()) {
       const ran = [];
@@ -490,49 +614,6 @@ var init_sql_migrations = __esm({
   }
 });
 
-// ../../blocklets/core/api/src/libs/env.ts
-function readConfig(key) {
-  const injected = activeConfig?.[key];
-  if (injected !== void 0 && injected !== null) return String(injected);
-  const fromEnv = process.env[key];
-  return fromEnv === void 0 ? void 0 : fromEnv;
-}
-var import_env, activeConfig, blockletAppPid, env_default;
-var init_env = __esm({
-  "../../blocklets/core/api/src/libs/env.ts"() {
-    "use strict";
-    import_env = require("@blocklet/sdk/lib/env");
-    blockletAppPid = () => readConfig("BLOCKLET_APP_PID");
-    env_default = {
-      ...import_env.env
-    };
-  }
-});
-
-// ../../blocklets/core/api/src/libs/tenant.ts
-function getDefaultInstanceDid() {
-  const did = overrideDefaultInstanceDid || blockletAppPid() || "";
-  if (!did) {
-    throw new TenantError(TENANT_CONTEXT_MISSING, "app DID is not configured for this deployment");
-  }
-  return did;
-}
-var TENANT_CONTEXT_MISSING, TenantError, overrideDefaultInstanceDid;
-var init_tenant = __esm({
-  "../../blocklets/core/api/src/libs/tenant.ts"() {
-    "use strict";
-    init_env();
-    TENANT_CONTEXT_MISSING = "TENANT_CONTEXT_MISSING";
-    TenantError = class extends Error {
-      constructor(code, message) {
-        super(message);
-        this.name = "TenantError";
-        this.code = code;
-      }
-    };
-  }
-});
-
 // ../../blocklets/core/api/src/libs/drivers/identity.ts
 function createDefaultIdentityDriver() {
   return {

package/dist/index.d.ts

@@ -20,6 +20,9 @@ export type TenancySlot = {
     instanceDid: string;
 } | {
     mode: 'multi';
+    /** D6 (optional): enumerate all known tenant instanceDids so start()
+     *  bootstraps each at startup. Absent => host bootstraps per tenant. */
+    listInstanceDids?: () => Promise<string[]> | string[];
 };
 export interface PaymentCoreSlots {
     config: Record<string, any>;
@@ -32,17 +35,54 @@ export interface PaymentCoreSlots {
     identity?: IdentityDriver;
     secrets?: SecretsDriver;
     tenancy?: TenancySlot;
+    /**
+     * P3a (README D3 / F3) — host-provided static/SPA handler, wired onto the full
+     * node hono app AFTER the api/connect routes (see blocklets/core/api/src/
+     * service.ts:81 staticHandler + buildHonoApp's attachStatic). arc-node injects
+     * its own clean handler (webRoot static + SPA fallback, no window.blocklet
+     * injection — bootstrap is build-time, P2); the CF/standalone worker serves
+     * assets via env.ASSETS and omits this. Typed `any` (not `Hono`) so this
+     * package's .d.ts stays free of a hono type dependency — same convention as
+     * `handler: any`. NOTE: no parallel webRoot core slot is added — webRoot is an
+     * arc-side option (D3); and `attachNodeStatic` is deliberately NOT exported
+     * (it binds blocklet-server's isProduction/blockletAppDir — G2).
+     */
+    staticHandler?: (app: any) => void;
 }
 export interface PaymentCoreLifecycle {
     start: () => Promise<void>;
     stop: () => Promise<void>;
 }
+/** Options for svc.http.fetch — basePath is stripped to reach the internal /api/*. */
+export interface PaymentFetchOptions {
+    /** the host's mount prefix (e.g. "/.well-known/payment"); stripped, no alias special-case */
+    basePath?: string;
+}
 export interface PaymentCoreService {
-    /** (req, res) handler — mount under the host's prefix (lazy: node app shell) */
+    /**
+     * Phase 4 (express→hono): the full node HONO app (was express.Express). Mount
+     * under the host's prefix; built lazily (node app shell). Typed `any` so this
+     * package's .d.ts stays free of a hono type dependency — the runtime value is a
+     * `hono` instance.
+     */
     handler: any;
-    /** embeddable HTTP surface — `resourceRoutes` for hosts owning their own shell */
+    /** embeddable HTTP surface for hosts owning their own shell */
     http: {
+        /**
+         * Phase 4 (express→hono): the resource routes as a HONO app (was
+         * express.Router) — `/api/healthz` + the migrated domains. A host (CF worker)
+         * mounts it via `app.route('/', resourceRoutes)`. Typed `any` (see `handler`).
+         */
         resourceRoutes: any;
+        /**
+         * D5: Web-Fetch entry over the FULL node hono app. A Fetch-native host
+         * (arc-node) forwards a Web Request under {basePath} and gets a Web Response
+         * — base-strip, raw-body (Stripe webhook signature), originalUrl, multi
+         * Set-Cookie / redirect passthrough handled inside (lazy Node adapter). The
+         * host writes zero express/req-res bridge. Node-only: a workerd host that
+         * mounts `resourceRoutes` must never call this.
+         */
+        fetch: (request: Request, opts?: PaymentFetchOptions) => Promise<Response>;
     };
     rpc: {
         entitlements: {
@@ -57,5 +97,36 @@ export interface PaymentCoreService {
         };
     };
     lifecycle: PaymentCoreLifecycle;
+    /**
+     * D6 — idempotent per-tenant bootstrap (currency logos, overdraft prices,
+     * exchange-rate-health schedule, per-tenant integrations) run inside the
+     * tenant context. Multi-mode hosts MUST call this per tenant; single mode
+     * bootstraps the default tenant from lifecycle.start automatically.
+     */
+    bootstrapTenant: (instanceDid: string) => Promise<void>;
+    /**
+     * Idempotent per-tenant base-data provisioning — seeds the default ArcBlock
+     * payment methods + base currencies scoped to the tenant's instanceDid (the
+     * `20230911-seeding` migration writes them with no instance_did, invisible to
+     * multi-tenant queries). A multi-tenant host calls this per tenant (e.g. lazily
+     * on first request) so downstream entities (meters/products/prices/
+     * subscriptions) have a payment method to depend on. No secrets / no chain
+     * calls; skips if the tenant already has an arcblock method.
+     */
+    provisionTenant: (instanceDid: string) => Promise<void>;
 }
+/**
+ * P3b (README D3 / F3) — build a clean node static/SPA handler over `webRoot`
+ * for the `staticHandler` slot. A Fetch-native node host (arc) calls this with
+ * `dirname(require.resolve('@arcblock/payment-service/package.json')) + '/web'`
+ * and passes the result as `slots.staticHandler`. It serves index.html VERBATIM
+ * (no server-side window.blocklet injection — bootstrap is build-time, P2) and
+ * is NOT the blocklet-server-bound attachNodeStatic (G2). Node-only: a workerd
+ * host serves assets via env.ASSETS and never calls this.
+ *
+ * Lazy-require keeps this package's import side-effect-free; the `as string`
+ * cast drives the dual build (tsc widens → .d.ts stays self-contained; esbuild
+ * sees the literal → bundles the impl into dist).
+ */
+export declare function createNodeStaticHandler(webRoot: string): (app: any) => void;
 export declare function createEmbeddedPaymentService(slots: PaymentCoreSlots): PaymentCoreService;