@zintrust/core 0.1.28 → 0.1.29

package/src/config/app.js

@@ -0,0 +1,184 @@
+/**
+ * Application Configuration
+ * Core application settings
+ * Sealed namespace for immutability
+ */
+import { Env } from './env.js';
+// Cache getSafeEnv result at module load time to avoid repeated object creation
+const anyEnv = Env;
+const readEnvString = (key, defaultValue = '') => {
+    if (typeof anyEnv.get === 'function') {
+        return anyEnv.get(key, defaultValue) ?? '';
+    }
+    if (typeof process !== 'undefined') {
+        const raw = process.env?.[key];
+        if (typeof raw === 'string' && raw !== '')
+            return raw;
+    }
+    return defaultValue;
+};
+const readEnvInt = (key, defaultValue = 0) => {
+    if (typeof anyEnv.getInt === 'function') {
+        return anyEnv.getInt(key, defaultValue);
+    }
+    const raw = readEnvString(key, String(defaultValue));
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) ? parsed : defaultValue;
+};
+const readEnvBool = (key, defaultValue = false) => {
+    if (typeof anyEnv.getBool === 'function') {
+        return anyEnv.getBool(key, defaultValue);
+    }
+    const raw = readEnvString(key, '');
+    if (raw === '')
+        return defaultValue;
+    return raw.toLowerCase() === 'true' || raw === '1';
+};
+const readAppPort = () => {
+    if (typeof anyEnv.getInt === 'function') {
+        return anyEnv.getInt('PORT', anyEnv.getInt('APP_PORT', 3000));
+    }
+    if (typeof Env.PORT === 'number' && Number.isFinite(Env.PORT) && Env.PORT > 0) {
+        return Env.PORT;
+    }
+    const portRaw = readEnvString('PORT', readEnvString('APP_PORT', '3000'));
+    const parsed = Number.parseInt(portRaw, 10);
+    return Number.isFinite(parsed) ? parsed : 3000;
+};
+/**
+ * Check if running on AWS Lambda
+ */
+function isLambda() {
+    return (Env.getBool('LAMBDA_TASK_ROOT') === true ||
+        Env.getBool('AWS_LAMBDA_FUNCTION_NAME') === true ||
+        Env.getBool('AWS_EXECUTION_ENV') === true);
+}
+/**
+ * Check if running on Cloudflare Workers
+ */
+function isCloudflare() {
+    return globalThis.CF !== undefined;
+}
+/**
+ * Check if running on Deno
+ */
+function isDeno() {
+    return globalThis.Deno !== undefined;
+}
+/**
+ * Detect current runtime environment
+ */
+const detectRuntime = () => {
+    const explicit = Env.get('RUNTIME').trim();
+    if (explicit !== '' && explicit !== 'auto')
+        return explicit;
+    // Auto-detection logic
+    if (isLambda() === true) {
+        return 'lambda';
+    }
+    if (isCloudflare() === true) {
+        return 'cloudflare';
+    }
+    if (isDeno() === true) {
+        return 'deno';
+    }
+    // Default to nodejs for containers (Fargate, Docker, Cloud Run)
+    return 'nodejs';
+};
+const resolvedNodeEnv = readEnvString('NODE_ENV', 'development');
+// Cache getSafeEnv result at module load time to avoid repeated object creation
+const cachedSafeEnv = {
+    ...(typeof process === 'undefined' ? {} : process.env),
+    NODE_ENV: resolvedNodeEnv,
+    MODE: resolvedNodeEnv,
+    npm_config_scripts_prepend_node_path: 'true',
+};
+const useRawQry = readEnvString('USE_RAW_QRY');
+if (useRawQry !== '')
+    cachedSafeEnv.USE_RAW_QRY = useRawQry;
+const serviceApiKey = readEnvString('SERVICE_API_KEY');
+if (serviceApiKey !== '')
+    cachedSafeEnv.SERVICE_API_KEY = serviceApiKey;
+const serviceJwtSecret = readEnvString('SERVICE_JWT_SECRET') || readEnvString('APP_KEY');
+if (serviceJwtSecret !== '')
+    cachedSafeEnv.SERVICE_JWT_SECRET = serviceJwtSecret;
+const baseUrl = readEnvString('BASE_URL');
+if (baseUrl !== '')
+    cachedSafeEnv['BASE_URL'] = baseUrl;
+if (typeof Env.SAFE_PATH === 'string' && Env.SAFE_PATH !== '') {
+    cachedSafeEnv['PATH'] = Env.SAFE_PATH;
+}
+const getSafeEnv = () => cachedSafeEnv;
+const normalizeMode = () => {
+    const value = readEnvString('NODE_ENV', Env.NODE_ENV ?? 'development');
+    if (value === 'production' || value === 'pro' || value === 'prod')
+        return 'production';
+    if (value === 'testing' || value === 'test')
+        return 'testing';
+    return 'development';
+};
+const Prefix = () => {
+    const app_name = (Env.APP_NAME || 'zintrust').toLowerCase().replaceAll(/\s/g, '_');
+    const env = Env.NODE_ENV;
+    return `${app_name}_zintrust_${env}`;
+};
+const appConfigObj = {
+    /**
+     * Application name
+     */
+    name: readEnvString('APP_NAME', Env.APP_NAME),
+    /**
+     * Application prefix
+     */
+    prefix: Prefix(),
+    /**
+     * Application environment
+     */
+    environment: normalizeMode(),
+    /**
+     * Application port
+     */
+    port: readAppPort(),
+    /**
+     * Application host
+     */
+    host: readEnvString('HOST', Env.HOST),
+    /**
+     * Is development environment
+     */
+    isDevelopment() {
+        return this.environment === 'development';
+    },
+    /**
+     * Is production environment
+     */
+    isProduction() {
+        return this.environment === 'production';
+    },
+    /**
+     * Is testing environment
+     */
+    isTesting() {
+        return this.environment === 'testing';
+    },
+    /**
+     * Application debug mode
+     */
+    debug: readEnvBool('DEBUG', Env.DEBUG),
+    /**
+     * Application timezone
+     */
+    timezone: readEnvString('APP_TIMEZONE', Env.APP_TIMEZONE),
+    /**
+     * Request timeout (milliseconds)
+     */
+    requestTimeout: readEnvInt('REQUEST_TIMEOUT', Env.REQUEST_TIMEOUT),
+    /**
+     * Max request body size
+     */
+    maxBodySize: readEnvInt('MAX_BODY_SIZE', Env.MAX_BODY_SIZE),
+    getSafeEnv,
+    detectRuntime,
+};
+export const appConfig = Object.freeze(appConfigObj);
+export { getSafeEnv };

package/src/config/broadcast.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Broadcast Configuration
+ *
+ * Centralizes broadcast driver selection and provider env mappings.
+ * Driver selection must be dynamic (tests may mutate process.env).
+ */
+import type { BroadcastDrivers, KnownBroadcastDriverConfig } from './type';
+export type BroadcastConfigOverrides = Partial<{
+    default: string;
+    drivers: Record<string, KnownBroadcastDriverConfig>;
+}>;
+type BroadcastRuntimeConfig = {
+    default: string;
+    drivers: BroadcastDrivers;
+    getDriverName: () => string;
+    getDriverConfig: (name?: string) => KnownBroadcastDriverConfig;
+};
+declare const createBroadcastConfig: () => BroadcastRuntimeConfig;
+export type BroadcastConfig = ReturnType<typeof createBroadcastConfig>;
+declare const broadcastConfig: BroadcastConfig;
+export default broadcastConfig;
+//# sourceMappingURL=broadcast.d.ts.map

package/src/config/broadcast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broadcast.d.ts","sourceRoot":"","sources":["../../../src/config/broadcast.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAEV,gBAAgB,EAEhB,0BAA0B,EAI3B,MAAM,cAAc,CAAC;AAItB,MAAM,MAAM,wBAAwB,GAAG,OAAO,CAAC;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;CACrD,CAAC,CAAC;AAEH,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,aAAa,EAAE,MAAM,MAAM,CAAC;IAC5B,eAAe,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,0BAA0B,CAAC;CAChE,CAAC;AA0EF,QAAA,MAAM,qBAAqB,QAAO,sBAoDjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAqBvE,QAAA,MAAM,eAAe,EAAE,eAYrB,CAAC;AAEH,eAAe,eAAe,CAAC"}

package/src/config/broadcast.js

@@ -0,0 +1,138 @@
+/**
+ * Broadcast Configuration
+ *
+ * Centralizes broadcast driver selection and provider env mappings.
+ * Driver selection must be dynamic (tests may mutate process.env).
+ */
+import { Env } from './env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
+const normalizeDriverName = (value) => value.trim().toLowerCase();
+const hasOwn = (obj, key) => {
+    return Object.hasOwn(obj, key);
+};
+const getDefaultBroadcaster = (drivers) => {
+    const envSelectedRaw = Env.get('BROADCAST_CONNECTION', Env.get('BROADCAST_DRIVER', 'inmemory'));
+    const value = normalizeDriverName(envSelectedRaw ?? 'inmemory');
+    if (value.length > 0 && hasOwn(drivers, value))
+        return value;
+    if (envSelectedRaw.trim().length > 0) {
+        throw ErrorFactory.createConfigError(`Broadcast driver not configured: ${value}`);
+    }
+    return hasOwn(drivers, 'inmemory') ? 'inmemory' : (Object.keys(drivers)[0] ?? 'inmemory');
+};
+const getPusherConfig = () => ({
+    driver: 'pusher',
+    appId: Env.get('PUSHER_APP_ID', ''),
+    key: Env.get('PUSHER_APP_KEY', ''),
+    secret: Env.get('PUSHER_APP_SECRET', ''),
+    cluster: Env.get('PUSHER_APP_CLUSTER', ''),
+    useTLS: Env.getBool('PUSHER_USE_TLS', true),
+});
+const getRedisConfig = () => ({
+    driver: 'redis',
+    host: Env.get('BROADCAST_REDIS_HOST', Env.get('REDIS_HOST', 'localhost')),
+    port: Env.getInt('BROADCAST_REDIS_PORT', Env.getInt('REDIS_PORT', 6379)),
+    password: Env.get('BROADCAST_REDIS_PASSWORD', Env.get('REDIS_PASSWORD', '')),
+    channelPrefix: Env.get('BROADCAST_CHANNEL_PREFIX', 'broadcast:'),
+});
+const getRedisHttpsConfig = () => ({
+    driver: 'redishttps',
+    endpoint: Env.get('REDIS_HTTPS_ENDPOINT', ''),
+    token: Env.get('REDIS_HTTPS_TOKEN', ''),
+    channelPrefix: Env.get('BROADCAST_CHANNEL_PREFIX', 'broadcast:'),
+});
+const getBroadcastDriver = (config, name) => {
+    const selected = normalizeDriverName(String(name ?? config.default));
+    const broadcasterName = selected === 'default' ? normalizeDriverName(config.default) : selected;
+    const isExplicitSelection = name !== undefined &&
+        String(name).trim().length > 0 &&
+        normalizeDriverName(String(name)) !== 'default';
+    if (broadcasterName.length > 0 && hasOwn(config.drivers, broadcasterName)) {
+        const resolved = config.drivers[broadcasterName];
+        if (resolved !== undefined)
+            return resolved;
+    }
+    if (isExplicitSelection) {
+        throw ErrorFactory.createConfigError(`Broadcast driver not configured: ${broadcasterName}`);
+    }
+    const fallback = config.drivers['inmemory'] ?? Object.values(config.drivers)[0];
+    if (fallback !== undefined)
+        return fallback;
+    throw ErrorFactory.createConfigError('No broadcast drivers are configured');
+};
+const createBroadcastConfig = () => {
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Broadcast) ?? {};
+    const broadcastConfigObj = {
+        /**
+         * Default broadcaster name (normalized).
+         */
+        get default() {
+            const overrideDefault = overrides.default;
+            if (typeof overrideDefault === 'string' && overrideDefault.trim().length > 0) {
+                const value = normalizeDriverName(overrideDefault);
+                if (value.length > 0 && hasOwn(this.drivers, value))
+                    return value;
+                throw ErrorFactory.createConfigError(`Broadcast driver not configured: ${value}`);
+            }
+            return getDefaultBroadcaster(this.drivers);
+        },
+        /**
+         * Broadcast drivers.
+         *
+         * You may add custom named broadcasters (e.g. `ops`, `billing`) that point to any
+         * known driver config.
+         */
+        get drivers() {
+            return {
+                inmemory: { driver: 'inmemory' },
+                pusher: getPusherConfig(),
+                redis: getRedisConfig(),
+                redishttps: getRedisHttpsConfig(),
+                ...overrides.drivers,
+            };
+        },
+        /**
+         * Normalized broadcast driver name for the default broadcaster.
+         */
+        getDriverName() {
+            return normalizeDriverName(this.default);
+        },
+        /**
+         * Get a config object for the currently selected driver.
+         * Defaults to inmemory for unknown/unsupported names.
+         */
+        getDriverConfig(name) {
+            return getBroadcastDriver(this, name);
+        },
+    };
+    return Object.freeze(broadcastConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureBroadcastConfig = () => {
+    if (cached)
+        return cached;
+    cached = createBroadcastConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
+};
+const broadcastConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureBroadcastConfig()[prop];
+    },
+    ownKeys() {
+        ensureBroadcastConfig();
+        return Reflect.ownKeys(proxyTarget);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureBroadcastConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});
+export default broadcastConfig;

package/src/config/cache.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cache Configuration
+ * Caching drivers and settings
+ * Sealed namespace for immutability
+ */
+import type { CacheConfigInput, CacheDriverConfig } from './type';
+export type CacheConfigOverrides = Partial<{
+    default: string;
+    drivers: CacheConfigInput['drivers'];
+    keyPrefix: string;
+    ttl: number;
+}>;
+declare const createCacheConfig: () => {
+    default: string;
+    drivers: CacheConfigInput["drivers"];
+    getDriver: (name?: string) => CacheDriverConfig;
+    keyPrefix: string;
+    ttl: number;
+};
+export type CacheConfig = ReturnType<typeof createCacheConfig>;
+export declare const cacheConfig: CacheConfig;
+export {};
+//# sourceMappingURL=cache.d.ts.map

package/src/config/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/config/cache.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAIxE,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC,CAAC;AA0BH,QAAA,MAAM,iBAAiB,QAAO;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAC;IACrC,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,iBAAiB,CAAC;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;CA4Fb,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAqB/D,eAAO,MAAM,WAAW,EAAE,WAYxB,CAAC"}

package/src/config/cache.js

@@ -0,0 +1,125 @@
+/**
+ * Cache Configuration
+ * Caching drivers and settings
+ * Sealed namespace for immutability
+ */
+import { Env } from './env.js';
+import { ErrorFactory } from '../exceptions/ZintrustError.js';
+import { StartupConfigFile, StartupConfigFileRegistry } from '../runtime/StartupConfigFileRegistry.js';
+const getCacheDriver = (config, name) => {
+    const selected = String(name ?? config.default).trim();
+    const storeName = selected === 'default' ? String(config.default).trim() : selected;
+    const isExplicitSelection = name !== undefined && String(name).trim().length > 0 && String(name).trim() !== 'default';
+    if (storeName.length > 0 && Object.hasOwn(config.drivers, storeName)) {
+        const resolved = config.drivers[storeName];
+        if (resolved !== undefined)
+            return resolved;
+    }
+    if (isExplicitSelection) {
+        throw ErrorFactory.createConfigError(`Cache store not configured: ${storeName}`);
+    }
+    if (Object.keys(config.drivers ?? {}).length === 0) {
+        throw ErrorFactory.createConfigError('No cache stores are configured');
+    }
+    throw ErrorFactory.createConfigError(`Cache default store not configured: ${storeName || '<empty>'}`);
+};
+const createCacheConfig = () => {
+    const baseDefault = (() => {
+        const envConnection = Env.get('CACHE_CONNECTION', '').trim();
+        const envDriver = typeof Env.CACHE_DRIVER === 'string'
+            ? String(Env.CACHE_DRIVER)
+            : Env.get('CACHE_DRIVER', 'memory');
+        const selected = envConnection.length > 0 ? envConnection : String(envDriver ?? 'memory');
+        return selected.trim().toLowerCase();
+    })();
+    const baseDrivers = {
+        memory: {
+            driver: 'memory',
+            ttl: Env.getInt('CACHE_MEMORY_TTL', 3600),
+        },
+        redis: {
+            driver: 'redis',
+            host: Env.get('REDIS_HOST', 'localhost'),
+            port: Env.getInt('REDIS_PORT', 6379),
+            ttl: Env.getInt('CACHE_REDIS_TTL', 3600),
+        },
+        mongodb: {
+            driver: 'mongodb',
+            uri: Env.get('MONGO_URI'),
+            db: Env.get('MONGO_DB', 'zintrust_cache'),
+            ttl: Env.getInt('CACHE_MONGO_TTL', 3600),
+        },
+        kv: {
+            driver: 'kv',
+            ttl: Env.getInt('CACHE_KV_TTL', 3600),
+        },
+        'kv-remote': {
+            driver: 'kv-remote',
+            ttl: Env.getInt('CACHE_KV_TTL', 3600),
+        },
+    };
+    const overrides = StartupConfigFileRegistry.get(StartupConfigFile.Cache) ?? {};
+    const mergedDrivers = {
+        ...baseDrivers,
+        ...overrides.drivers,
+    };
+    const mergedDefault = typeof overrides.default === 'string' && overrides.default.trim() !== ''
+        ? overrides.default.trim().toLowerCase()
+        : baseDefault;
+    const mergedKeyPrefix = typeof overrides.keyPrefix === 'string' && overrides.keyPrefix.length > 0
+        ? overrides.keyPrefix
+        : Env.get('CACHE_KEY_PREFIX', 'zintrust:');
+    const mergedTtl = typeof overrides.ttl === 'number' && Number.isFinite(overrides.ttl) ? overrides.ttl : 3600;
+    const cacheConfigObj = {
+        /**
+         * Default cache driver
+         */
+        default: mergedDefault,
+        /**
+         * Cache drivers
+         */
+        drivers: mergedDrivers,
+        /**
+         * Get cache driver config
+         */
+        getDriver(name) {
+            return getCacheDriver(this, name);
+        },
+        /**
+         * Key prefix for all cache keys
+         */
+        keyPrefix: mergedKeyPrefix,
+        /**
+         * Default cache TTL (seconds)
+         */
+        ttl: mergedTtl,
+    };
+    return Object.freeze(cacheConfigObj);
+};
+let cached = null;
+const proxyTarget = {};
+const ensureCacheConfig = () => {
+    if (cached)
+        return cached;
+    cached = createCacheConfig();
+    try {
+        Object.defineProperties(proxyTarget, Object.getOwnPropertyDescriptors(cached));
+    }
+    catch {
+        // best-effort
+    }
+    return cached;
+};
+export const cacheConfig = new Proxy(proxyTarget, {
+    get(_target, prop) {
+        return ensureCacheConfig()[prop];
+    },
+    ownKeys() {
+        ensureCacheConfig();
+        return Reflect.ownKeys(proxyTarget);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        ensureCacheConfig();
+        return Object.getOwnPropertyDescriptor(proxyTarget, prop);
+    },
+});

package/src/config/cloudflare.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cloudflare Workers Environment Access
+ *
+ * Centralizes access to Workers bindings via globalThis.env.
+ * This keeps runtime-specific globals out of adapters/drivers.
+ */
+import type { KVNamespace, WorkersEnv } from './type';
+import type { DatabaseConfig, ID1Database } from '../orm/DatabaseAdapter';
+export declare const Cloudflare: Readonly<{
+    getWorkersEnv: () => WorkersEnv | null;
+    getD1Binding: (config: DatabaseConfig) => ID1Database | null;
+    getKVBinding: (bindingName?: string) => KVNamespace | null;
+}>;
+//# sourceMappingURL=cloudflare.d.ts.map

package/src/config/cloudflare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare.d.ts","sourceRoot":"","sources":["../../../src/config/cloudflare.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA8BxE,eAAO,MAAM,UAAU;yBA5BG,UAAU,GAAG,IAAI;2BAOb,cAAc,KAAG,WAAW,GAAG,IAAI;4CAanB,WAAW,GAAG,IAAI;EAY9D,CAAC"}

package/src/config/cloudflare.js

@@ -0,0 +1,38 @@
+/**
+ * Cloudflare Workers Environment Access
+ *
+ * Centralizes access to Workers bindings via globalThis.env.
+ * This keeps runtime-specific globals out of adapters/drivers.
+ */
+const getWorkersEnv = () => {
+    const env = globalThis.env;
+    if (env === undefined || env === null)
+        return null;
+    if (typeof env !== 'object')
+        return null;
+    return env;
+};
+const getD1Binding = (config) => {
+    if (config.d1 !== undefined && config.d1 !== null)
+        return config.d1;
+    const env = getWorkersEnv();
+    const envDb = env === null ? undefined : env['DB'];
+    if (envDb !== undefined)
+        return envDb;
+    const globalDb = globalThis.DB;
+    if (globalDb !== undefined)
+        return globalDb;
+    return null;
+};
+const getKVBinding = (bindingName = 'CACHE') => {
+    const env = getWorkersEnv();
+    if (env === null)
+        return null;
+    const kv = env[bindingName];
+    return kv ?? null;
+};
+export const Cloudflare = Object.freeze({
+    getWorkersEnv,
+    getD1Binding,
+    getKVBinding,
+});