@naylence/runtime 0.3.5-test.6 → 0.3.5-test.8

package/dist/node/node.mjs

@@ -1,12 +1,12 @@
 import { FlowFlags, ConnectorState, generateId, ConnectorStateUtils, FameResponseType, createFameEnvelope, parseAddressComponents, FameAddress, DEFAULT_POLLING_TIMEOUT_MS, extractEnvelopeAndContext, createChannelMessage, DeliveryOriginType, parseAddress, formatAddress, formatAddressFromComponents, localDeliveryContext, Binding, generateIdAsync, snakeToCamelObject, getDefaultFameConfigResolver, setDefaultFameConfigResolver, makeResponse, isFameMessageResponse, parseRequest, makeRequest, DEFAULT_INVOKE_TIMEOUT_MILLIS, parseResponse, FameFabric, isFameMessageService, isFameRPCService, FameServiceProxy, AuthorizationContextSchema, withFabric, SigningMaterial, FameDeliveryContextSchema, SecurityContextSchema, FameEnvelopeSchema, serializeEnvelope, FameChannelMessage, deserializeEnvelope, SINK_CAPABILITY, FameFabricFactory } from '@naylence/core';
 export * from '@naylence/core';
-import { ExtensionManager, ExpressionEvaluationPolicy, AbstractResourceFactory, createResource as createResource$1, createDefaultResource, Registry, Expressions, registerFactory } from '@naylence/factory';
+import { z, ZodError } from 'zod';
+import { ExtensionManager, ExpressionEvaluationPolicy, AbstractResourceFactory, createResource as createResource$1, createDefaultResource, registerFactory, Expressions, Registry } from '@naylence/factory';
 import express from 'express';
 import { sha256 } from '@noble/hashes/sha2.js';
 import fastify from 'fastify';
 import websocketPlugin from '@fastify/websocket';
 import fs from 'fs';
-import { z, ZodError } from 'zod';
 import { parse } from 'yaml';
 import { utf8ToBytes, bytesToHex, randomBytes, concatBytes } from '@noble/hashes/utils.js';
 import fs$1 from 'node:fs';
@@ -745,7 +745,7 @@ function coerceNumber$1(value) {
     }
     return undefined;
 }
-function coerceBoolean(value) {
+function coerceBoolean$1(value) {
     if (typeof value === 'boolean') {
         return value;
     }
@@ -769,7 +769,7 @@ function normalizeTaskSpawnerConfig(config = {}) {
         0;
     const defaultTimeout = coerceNumber$1(firstDefined(source, ['defaultTimeout', 'default_timeout'])) ??
         0;
-    const autoCleanup = coerceBoolean(firstDefined(source, ['autoCleanup', 'auto_cleanup'])) ??
+    const autoCleanup = coerceBoolean$1(firstDefined(source, ['autoCleanup', 'auto_cleanup'])) ??
         true;
     return {
         maxConcurrent,
@@ -792,7 +792,7 @@ function normalizeSpawnOptions(options = {}) {
 function normalizeShutdownOptions(options = {}) {
     const source = options;
     const gracePeriod = coerceNumber$1(firstDefined(source, ['gracePeriod', 'grace_period'])) ?? 2000;
-    const cancelHanging = coerceBoolean(firstDefined(source, ['cancelHanging', 'cancel_hanging'])) ??
+    const cancelHanging = coerceBoolean$1(firstDefined(source, ['cancelHanging', 'cancel_hanging'])) ??
         true;
     const joinTimeout = coerceNumber$1(firstDefined(source, ['joinTimeout', 'join_timeout'])) ?? 1000;
     return {
@@ -4380,8 +4380,46 @@ class StorageProviderFactory extends AbstractResourceFactory {
         return instance;
     }
 }
+function registerStorageProviderFactory(type, factory) {
+    registerFactory(STORAGE_PROVIDER_FACTORY_BASE_TYPE, type, factory);
+}
+
+const inMemoryStorageProviderConfigSchema = z
+    .object({
+    type: z
+        .literal('InMemoryStorageProvider')
+        .default('InMemoryStorageProvider'),
+})
+    .passthrough();
+class InMemoryStorageProviderFactory extends StorageProviderFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'InMemoryStorageProvider';
+    }
+    async create(config) {
+        // Validate configuration and ensure correct type information
+        const candidate = config ?? { type: 'InMemoryStorageProvider' };
+        inMemoryStorageProviderConfigSchema.parse({
+            type: candidate.type,
+            ...candidate,
+        });
+        return new InMemoryStorageProvider();
+    }
+}
+registerStorageProviderFactory('InMemoryStorageProvider', InMemoryStorageProviderFactory);
 
 const CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE = 'CredentialProviderFactory';
+class CredentialProviderFactory extends AbstractResourceFactory {
+    static async createCredentialProvider(config, options = {}) {
+        const instance = config
+            ? await createResource$1(CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE, config, options)
+            : await createDefaultResource(CREDENTIAL_PROVIDER_FACTORY_BASE_TYPE, null, options);
+        if (!instance) {
+            throw new Error('Failed to create credential provider from configuration');
+        }
+        return instance;
+    }
+}
 
 function readEnvironmentVariable(name) {
     if (!name) {
@@ -4694,8 +4732,9 @@ function isModuleNotFoundError(error) {
  * Wraps a dynamic import loader and enriches "module not found" failures with an actionable error message.
  */
 async function safeImport(loader, dependencyNameOrOptions, maybeOptions) {
-    const options = { dependencyName: dependencyNameOrOptions, ...(maybeOptions ?? {}) }
-        ;
+    const options = typeof dependencyNameOrOptions === 'string'
+        ? { dependencyName: dependencyNameOrOptions, ...(maybeOptions ?? {}) }
+        : dependencyNameOrOptions;
     const dependencyName = options.dependencyName;
     try {
         return await loader();
@@ -4717,6 +4756,219 @@ async function safeImport(loader, dependencyNameOrOptions, maybeOptions) {
     }
 }
 
+const indexedDBConfigSchema = z
+    .object({
+    type: z
+        .literal('IndexedDBStorageProvider')
+        .default('IndexedDBStorageProvider'),
+    mode: z
+        .union([z.literal('dx'), z.literal('hardened'), z.string()])
+        .optional()
+        .default('dx'),
+    dbName: z.string().min(1).default('naylence'),
+    version: z.union([z.number().int().positive(), z.string()]).default(1),
+    namespacePrefix: z.string().optional().default('kv'),
+    enableCaching: z.union([z.boolean(), z.string()]).optional(),
+    isEncrypted: z.union([z.boolean(), z.string()]).optional(),
+    masterKey: z
+        .union([z.string(), z.record(z.string(), z.unknown()), z.null()])
+        .optional()
+        .default(null),
+})
+    .passthrough();
+const TRUE_VALUES = new Set(['true', '1', 'yes', 'on']);
+const FALSE_VALUES = new Set(['false', '0', 'no', 'off', '']);
+function coerceBoolean(value, fieldName, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (TRUE_VALUES.has(normalized)) {
+            return true;
+        }
+        if (FALSE_VALUES.has(normalized)) {
+            return false;
+        }
+    }
+    throw new Error(`Expected a boolean-like value for '${fieldName}' but received '${String(value)}'`);
+}
+function normalizeIndexedDBConfig(config) {
+    const candidate = {
+        ...config,
+    };
+    if (candidate.dbName === undefined && typeof candidate.db_name === 'string') {
+        candidate.dbName = candidate.db_name;
+    }
+    if (candidate.namespacePrefix === undefined &&
+        typeof candidate.namespace_prefix === 'string') {
+        candidate.namespacePrefix = candidate.namespace_prefix;
+    }
+    if (candidate.enableCaching === undefined &&
+        candidate.enable_caching !== undefined) {
+        candidate.enableCaching = candidate.enable_caching;
+    }
+    if (candidate.isEncrypted === undefined &&
+        candidate.is_encrypted !== undefined) {
+        candidate.isEncrypted = candidate.is_encrypted;
+    }
+    if (candidate.masterKey === undefined && candidate.master_key !== undefined) {
+        candidate.masterKey = candidate.master_key;
+    }
+    const parsed = indexedDBConfigSchema.parse({
+        ...candidate,
+        type: 'IndexedDBStorageProvider',
+    });
+    const normalizedMode = (typeof parsed.mode === 'string' ? parsed.mode : 'dx').toLowerCase();
+    if (normalizedMode !== 'dx' && normalizedMode !== 'hardened') {
+        throw new Error("mode must be either 'dx' or 'hardened'");
+    }
+    const versionValue = typeof parsed.version === 'string'
+        ? parseInt(parsed.version, 10)
+        : parsed.version;
+    if (!Number.isInteger(versionValue) || versionValue <= 0) {
+        throw new Error('version must be a positive integer');
+    }
+    const enableCaching = coerceBoolean(parsed.enableCaching, 'enableCaching', normalizedMode === 'dx');
+    const isEncrypted = coerceBoolean(parsed.isEncrypted, 'isEncrypted', true);
+    let masterKeyConfig = null;
+    if (parsed.masterKey !== null && parsed.masterKey !== undefined) {
+        masterKeyConfig = SecretSource.normalize(parsed.masterKey);
+    }
+    if (normalizedMode === 'hardened' && !masterKeyConfig) {
+        throw new Error('hardened mode requires a masterKey configuration');
+    }
+    return {
+        type: 'IndexedDBStorageProvider',
+        mode: normalizedMode,
+        dbName: parsed.dbName,
+        version: versionValue,
+        namespacePrefix: parsed.namespacePrefix ?? 'kv',
+        enableCaching,
+        isEncrypted,
+        masterKey: masterKeyConfig,
+    };
+}
+class IndexedDBStorageProviderFactory extends StorageProviderFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'IndexedDBStorageProvider';
+        this.isDefault = true;
+        this.priority = 50;
+    }
+    async create(config) {
+        const normalized = normalizeIndexedDBConfig(config);
+        const { IndexedDBStorageProvider } = await getIndexedDbStorageProviderModule();
+        let masterKeyProvider = null;
+        if (normalized.masterKey) {
+            masterKeyProvider =
+                await CredentialProviderFactory.createCredentialProvider(normalized.masterKey);
+        }
+        return new IndexedDBStorageProvider({
+            mode: normalized.mode,
+            dbName: normalized.dbName,
+            version: normalized.version,
+            namespacePrefix: normalized.namespacePrefix,
+            enableCaching: normalized.enableCaching,
+            isEncrypted: normalized.isEncrypted,
+            masterKeyProvider,
+        });
+    }
+}
+let indexedDbStorageProviderModulePromise = null;
+function getIndexedDbStorageProviderModule() {
+    if (!indexedDbStorageProviderModulePromise) {
+        indexedDbStorageProviderModulePromise = safeImport(() => Promise.resolve().then(function () { return indexeddbStorageProvider; }), 'IndexedDBStorageProvider', {
+            helpMessage: 'Failed to load the IndexedDB storage provider. Ensure IndexedDB is available or install the required polyfills.',
+        });
+    }
+    return indexedDbStorageProviderModulePromise;
+}
+registerStorageProviderFactory('IndexedDBStorageProvider', IndexedDBStorageProviderFactory);
+
+const ENV_VAR_STORAGE_DB_DIRECTORY = 'FAME_STORAGE_DB_DIRECTORY';
+const ENV_VAR_STORAGE_MASTER_KEY = 'FAME_STORAGE_MASTER_KEY';
+const ENV_VAR_STORAGE_ENCRYPTED = 'FAME_STORAGE_ENCRYPTED';
+const PROFILE_NAME_MEMORY = 'memory';
+const PROFILE_NAME_INDEXEDDB = 'indexeddb';
+const PROFILE_NAME_SQLITE = 'sqlite';
+const PROFILE_NAME_ENCRYPTED_SQLITE = 'encrypted-sqlite';
+const storageProfileSchema = z
+    .object({
+    type: z.literal('StorageProfile').default('StorageProfile'),
+    profile: z
+        .string()
+        .optional()
+        .describe('Storage profile name (memory | indexeddb | sqlite | encrypted-sqlite)'),
+})
+    .passthrough();
+const MEMORY_PROFILE_CONFIG = {
+    type: 'InMemoryStorageProvider',
+};
+const INDEXEDDB_PROFILE_CONFIG = {
+    type: 'IndexedDBStorageProvider',
+};
+const SQLITE_PROFILE_CONFIG = {
+    type: 'SQLiteStorageProvider',
+    dbDirectory: Expressions.env(ENV_VAR_STORAGE_DB_DIRECTORY, './data/sqlite'),
+    isEncrypted: Expressions.env(ENV_VAR_STORAGE_ENCRYPTED, 'false'),
+    masterKey: Expressions.env(ENV_VAR_STORAGE_MASTER_KEY, ''),
+    isCached: true,
+};
+const ENCRYPTED_SQLITE_PROFILE_CONFIG = {
+    type: 'SQLiteStorageProvider',
+    dbDirectory: Expressions.env(ENV_VAR_STORAGE_DB_DIRECTORY, './data/sqlite'),
+    isEncrypted: 'true',
+    masterKey: Expressions.env(ENV_VAR_STORAGE_MASTER_KEY),
+    isCached: true,
+};
+// Base profile map with browser-safe options
+const BASE_PROFILE_MAP = {
+    [PROFILE_NAME_MEMORY]: MEMORY_PROFILE_CONFIG,
+    [PROFILE_NAME_INDEXEDDB]: INDEXEDDB_PROFILE_CONFIG,
+};
+// Extended profile map - can be augmented by Node.js environment
+const PROFILE_MAP$1 = {
+    ...BASE_PROFILE_MAP,
+};
+// Register SQLite profiles if we're in Node.js environment
+// This check allows the code to work in both browser and Node.js
+if (typeof process !== 'undefined' && process.versions?.node) {
+    PROFILE_MAP$1[PROFILE_NAME_SQLITE] = SQLITE_PROFILE_CONFIG;
+    PROFILE_MAP$1[PROFILE_NAME_ENCRYPTED_SQLITE] = ENCRYPTED_SQLITE_PROFILE_CONFIG;
+}
+class StorageProfileFactory extends StorageProviderFactory {
+    constructor() {
+        super(...arguments);
+        this.type = 'StorageProfile';
+    }
+    async create(config, options) {
+        const candidate = config ?? { type: 'StorageProfile' };
+        const parsed = storageProfileSchema.parse({
+            ...candidate,
+            type: 'StorageProfile',
+        });
+        const profileName = (parsed.profile ?? PROFILE_NAME_MEMORY).toLowerCase();
+        const profileConfig = PROFILE_MAP$1[profileName];
+        if (!profileConfig) {
+            throw new Error(`Unknown storage profile '${profileName}'. Supported profiles: ${Object.keys(PROFILE_MAP$1).join(', ')}`);
+        }
+        const createOptions = {
+            ...options,
+            validate: options?.validate ?? true,
+        };
+        const provider = await createResource$1(STORAGE_PROVIDER_FACTORY_BASE_TYPE, profileConfig, createOptions);
+        if (!provider) {
+            throw new Error(`Failed to create storage provider for profile '${profileName}'`);
+        }
+        return provider;
+    }
+}
+registerStorageProviderFactory('StorageProfile', StorageProfileFactory);
+
 const DEFAULT_DB_NAME$3 = 'naylence-secrets';
 const DEFAULT_STORE_NAME$1 = 'auto-master-key';
 const DEFAULT_KEY_ID$2 = 'master';
@@ -5465,6 +5717,11 @@ class IndexedDBStorageProvider extends EncryptedStorageProviderBase {
 }
 IndexedDBStorageProvider.supportedModes = new Set(['dx', 'hardened']);
 
+var indexeddbStorageProvider = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    IndexedDBStorageProvider: IndexedDBStorageProvider
+});
+
 const globalScope$1 = globalThis;
 const nodeStack = globalScope$1.__naylenceNodeStack__ ?? (globalScope$1.__naylenceNodeStack__ = []);
 function getCurrentNode() {