quidproquo-actionprocessor-node 0.0.262 → 0.1.0

package/lib/commonjs/dynamicActionProcessor/file/getFileWriteObjectJsonActionProcessor.js

@@ -47,17 +47,18 @@ const quidproquo_core_1 = require("quidproquo-core");
 const fs = __importStar(require("fs/promises"));
 const utils_1 = require("./utils");
 const getProcessFileWriteObjectJson = (config) => (qpqConfig) => {
-    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return (_a) => __awaiter(void 0, [_a], void 0, function* ({ drive, filepath, data }) {
         try {
-            const fullPath = (0, utils_1.resolveFilePath)(config, serviceName, drive, filepath);
+            const fullPath = (0, utils_1.resolveFilePath)(config, qpqConfig, drive, filepath);
             yield (0, utils_1.ensureParentDirectoryExists)(fullPath);
             const jsonString = JSON.stringify(data, null, 2);
             yield fs.writeFile(fullPath, jsonString, 'utf8');
             return (0, quidproquo_core_1.actionResult)(void 0);
         }
         catch (error) {
-            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.GenericError, `Error writing JSON file: ${error.message}`);
+            return (0, quidproquo_core_1.actionResultErrorFromCaughtError)(error, {
+                EACCES: () => (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.FileWriteObjectJsonErrorTypeEnum.AccessDenied, `Access denied writing file: ${filepath}`), // node fs code
+            });
         }
     });
 };

package/lib/commonjs/dynamicActionProcessor/file/getFileWriteTextContentsActionProcessor.js

@@ -47,16 +47,17 @@ const quidproquo_core_1 = require("quidproquo-core");
 const fs = __importStar(require("fs/promises"));
 const utils_1 = require("./utils");
 const getProcessFileWriteTextContents = (qpqConfig, config) => {
-    const serviceName = quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return (_a) => __awaiter(void 0, [_a], void 0, function* ({ drive, filepath, data }) {
         try {
-            const fullPath = (0, utils_1.resolveFilePath)(config, serviceName, drive, filepath);
+            const fullPath = (0, utils_1.resolveFilePath)(config, qpqConfig, drive, filepath);
             yield (0, utils_1.ensureParentDirectoryExists)(fullPath);
             yield fs.writeFile(fullPath, data, 'utf8');
             return (0, quidproquo_core_1.actionResult)(void 0);
         }
         catch (error) {
-            return (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.ErrorTypeEnum.GenericError, `Error writing file: ${error.message}`);
+            return (0, quidproquo_core_1.actionResultErrorFromCaughtError)(error, {
+                EACCES: () => (0, quidproquo_core_1.actionResultError)(quidproquo_core_1.FileWriteTextContentsErrorTypeEnum.AccessDenied, `Access denied writing file: ${filepath}`), // node fs code
+            });
         }
     });
 };

package/lib/commonjs/dynamicActionProcessor/file/index.js

@@ -33,6 +33,7 @@ const getFileListDirectoryActionProcessor_1 = require("./getFileListDirectoryAct
 const getFileReadBinaryContentsActionProcessor_1 = require("./getFileReadBinaryContentsActionProcessor");
 const getFileReadObjectJsonActionProcessor_1 = require("./getFileReadObjectJsonActionProcessor");
 const getFileReadTextContentsActionProcessor_1 = require("./getFileReadTextContentsActionProcessor");
+const getFileStreamOpenActionProcessor_1 = require("./getFileStreamOpenActionProcessor");
 const getFileWriteBinaryContentsActionProcessor_1 = require("./getFileWriteBinaryContentsActionProcessor");
 const getFileWriteObjectJsonActionProcessor_1 = require("./getFileWriteObjectJsonActionProcessor");
 const getFileWriteTextContentsActionProcessor_1 = require("./getFileWriteTextContentsActionProcessor");
@@ -40,7 +41,7 @@ __exportStar(require("./types"), exports);
 // Main export that accepts configuration
 const getFileActionProcessor = (fileStorageConfig) => {
     return (qpqConfig, dynamicModuleLoader) => __awaiter(void 0, void 0, void 0, function* () {
-        return (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (yield (0, getFileReadTextContentsActionProcessor_1.getFileReadTextContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileWriteTextContentsActionProcessor_1.getFileWriteTextContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileReadObjectJsonActionProcessor_1.getFileReadObjectJsonActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileWriteObjectJsonActionProcessor_1.getFileWriteObjectJsonActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileReadBinaryContentsActionProcessor_1.getFileReadBinaryContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileWriteBinaryContentsActionProcessor_1.getFileWriteBinaryContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileListDirectoryActionProcessor_1.getFileListDirectoryActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileExistsActionProcessor_1.getFileExistsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileDeleteActionProcessor_1.getFileDeleteActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileGenerateTemporarySecureUrlActionProcessor_1.getFileGenerateTemporarySecureUrlActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileGenerateTemporaryUploadSecureUrlActionProcessor_1.getFileGenerateTemporaryUploadSecureUrlActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileIsColdStorageActionProcessor_1.getFileIsColdStorageActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))));
+        return (Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (yield (0, getFileReadTextContentsActionProcessor_1.getFileReadTextContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileWriteTextContentsActionProcessor_1.getFileWriteTextContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileReadObjectJsonActionProcessor_1.getFileReadObjectJsonActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileWriteObjectJsonActionProcessor_1.getFileWriteObjectJsonActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileReadBinaryContentsActionProcessor_1.getFileReadBinaryContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileWriteBinaryContentsActionProcessor_1.getFileWriteBinaryContentsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileListDirectoryActionProcessor_1.getFileListDirectoryActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileExistsActionProcessor_1.getFileExistsActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileDeleteActionProcessor_1.getFileDeleteActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileGenerateTemporarySecureUrlActionProcessor_1.getFileGenerateTemporarySecureUrlActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileGenerateTemporaryUploadSecureUrlActionProcessor_1.getFileGenerateTemporaryUploadSecureUrlActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileIsColdStorageActionProcessor_1.getFileIsColdStorageActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))), (yield (0, getFileStreamOpenActionProcessor_1.getFileStreamOpenActionProcessor)(fileStorageConfig)(qpqConfig, dynamicModuleLoader))));
     });
 };
 exports.getFileActionProcessor = getFileActionProcessor;

package/lib/commonjs/dynamicActionProcessor/file/utils.d.ts

@@ -1,6 +1,7 @@
 import { QPQConfig } from 'quidproquo-core';
 import { FileStorageConfig } from './types';
 export declare const isStorageDriveNameValid: (drive: string, qpqConfig: QPQConfig) => boolean;
-export declare function resolveFilePath(fileStorageConfig: FileStorageConfig, service: string, drive: string, filepath: string): string;
+export declare function resolveDriveServiceName(drive: string, qpqConfig: QPQConfig): string;
+export declare function resolveFilePath(fileStorageConfig: FileStorageConfig, qpqConfig: QPQConfig, drive: string, filepath: string): string;
 export declare const ensureDirectoryExists: (dirPath: string) => Promise<void>;
 export declare const ensureParentDirectoryExists: (filePath: string) => Promise<void>;

package/lib/commonjs/dynamicActionProcessor/file/utils.js

@@ -43,6 +43,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureParentDirectoryExists = exports.ensureDirectoryExists = exports.isStorageDriveNameValid = void 0;
+exports.resolveDriveServiceName = resolveDriveServiceName;
 exports.resolveFilePath = resolveFilePath;
 const quidproquo_core_1 = require("quidproquo-core");
 const fs = __importStar(require("fs/promises"));
@@ -56,7 +57,16 @@ const isStorageDriveNameValid = (drive, qpqConfig) => {
     return true;
 };
 exports.isStorageDriveNameValid = isStorageDriveNameValid;
-function resolveFilePath(fileStorageConfig, service, drive, filepath) {
+// Resolve the service that owns a drive's on-disk location. Drives declared with
+// `owner.module` are shared across services, so every caller reads and writes
+// under the owner's folder — mirroring how AWS resolves the bucket by owner.
+function resolveDriveServiceName(drive, qpqConfig) {
+    var _a, _b;
+    const storageDrive = quidproquo_core_1.qpqCoreUtils.getStorageDriveByName(drive, qpqConfig);
+    return (_b = (_a = storageDrive === null || storageDrive === void 0 ? void 0 : storageDrive.owner) === null || _a === void 0 ? void 0 : _a.module) !== null && _b !== void 0 ? _b : quidproquo_core_1.qpqCoreUtils.getApplicationModuleName(qpqConfig);
+}
+function resolveFilePath(fileStorageConfig, qpqConfig, drive, filepath) {
+    const service = resolveDriveServiceName(drive, qpqConfig);
     const root = path.resolve(fileStorageConfig.storagePath, service, drive);
     // Block absolute paths and null bytes outright
     if (path.isAbsolute(filepath)) {

package/lib/esm/actionProcessor/core/index.d.ts

@@ -1,14 +1,4 @@
 import { ActionProcessorListResolver } from 'quidproquo-core';
-export * from './claudeAi';
-export * from './config';
-export * from './context';
-export * from './date';
-export * from './error';
-export * from './guid';
-export * from './log';
-export * from './math';
-export * from './network';
-export * from './platform';
-export * from './system';
-export * from './customActions';
+export * from './inlineFunction';
+export * from './stream';
 export declare const getCoreActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/core/index.js

@@ -1,37 +1,14 @@
-import { getClaudeAiActionProcessor } from './claudeAi';
-import { getConfigActionProcessor } from './config';
-import { getContextActionProcessor } from './context';
-import { getDateActionProcessor } from './date';
-import { getErrorActionProcessor } from './error';
-import { getGuidProcessor } from './guid';
-import { getLogActionProcessor } from './log';
-import { getMathActionProcessor } from './math';
-import { getNetworkActionProcessor } from './network';
-import { getPlatformActionProcessor } from './platform';
-import { getSystemActionProcessor } from './system';
-export * from './claudeAi';
-export * from './config';
-export * from './context';
-export * from './date';
-export * from './error';
-export * from './guid';
-export * from './log';
-export * from './math';
-export * from './network';
-export * from './platform';
-export * from './system';
-// Custom actions is not done here, as it has to be done last after all
-export * from './customActions';
+import { getCoreActionProcessor as getJsCoreActionProcessor } from 'quidproquo-actionprocessor-js';
+import { getInlineFunctionActionProcessor } from './inlineFunction';
+import { getStreamActionProcessor } from './stream';
+// The shared core processors (config, context, claudeAi, date, error, guid, log,
+// math, network, platform, system, customActions) are owned by
+// quidproquo-actionprocessor-js. Node builds on top of js and only adds the
+// processors that need a Node runtime (stream, inlineFunction).
+export * from './inlineFunction';
+export * from './stream';
 export const getCoreActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
-    ...(await getConfigActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getContextActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getClaudeAiActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getDateActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getErrorActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getGuidProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getLogActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getMathActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getNetworkActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getPlatformActionProcessor(qpqConfig, dynamicModuleLoader)),
-    ...(await getSystemActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getJsCoreActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getStreamActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getInlineFunctionActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/actionProcessor/core/inlineFunction/getInlineFunctionExecuteActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getInlineFunctionExecuteActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/core/inlineFunction/getInlineFunctionExecuteActionProcessor.js

@@ -0,0 +1,32 @@
+import { actionResult, actionResultError, createRuntime, ErrorTypeEnum, InlineFunctionActionType, qpqCoreUtils, QpqRuntimeType, } from 'quidproquo-core';
+import { randomUUID } from 'crypto';
+const getDateNow = () => new Date().toISOString();
+const getProcessExecute = (qpqConfig) => {
+    const moduleName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async (payload, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const inlineFunctions = qpqCoreUtils.getAllInlineFunctions(qpqConfig);
+        const inlineFunction = inlineFunctions.find((f) => f.functionName === payload.functionName);
+        if (!inlineFunction) {
+            return actionResultError(ErrorTypeEnum.NotFound, `Inline function not found: [${payload.functionName}]`);
+        }
+        const story = await dynamicModuleLoader(inlineFunction.runtime);
+        if (!story) {
+            return actionResultError(ErrorTypeEnum.NotFound, `Unable to dynamically load inline function: [${payload.functionName}]`);
+        }
+        const resolveStory = createRuntime(qpqConfig, {
+            context: session.context,
+            localContext: session.localContext,
+            depth: (session.depth || 0) + 1,
+            decodedAccessToken: session.decodedAccessToken,
+            correlation: session.correlation,
+        }, async () => actionProcessors, getDateNow, logger, `${moduleName}::${randomUUID()}`, QpqRuntimeType.EXECUTE_STORY, dynamicModuleLoader, inlineFunction.runtime, [], streamRegistry);
+        const storyResult = await resolveStory(story, [payload.payload]);
+        if (storyResult.error) {
+            return actionResultError(storyResult.error.errorType, storyResult.error.errorText, storyResult.error.errorStack ? `${payload.functionName} -> [${storyResult.error.errorStack}]` : payload.functionName);
+        }
+        return actionResult(storyResult.result);
+    };
+};
+export const getInlineFunctionExecuteActionProcessor = async (qpqConfig) => ({
+    [InlineFunctionActionType.Execute]: getProcessExecute(qpqConfig),
+});

package/lib/esm/actionProcessor/core/{network/getNetworkRequestActionProcessor.d.ts → inlineFunction/index.d.ts}

@@ -1,2 +1,2 @@
 import { ActionProcessorListResolver } from 'quidproquo-core';
-export declare const getNetworkRequestActionProcessor: ActionProcessorListResolver;
+export declare const getInlineFunctionActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/core/inlineFunction/index.js

@@ -0,0 +1,4 @@
+import { getInlineFunctionExecuteActionProcessor } from './getInlineFunctionExecuteActionProcessor';
+export const getInlineFunctionActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getInlineFunctionExecuteActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/{commonjs/actionProcessor/core/context/getContextListActionProcessor.d.ts → esm/actionProcessor/core/stream/getStreamCloseActionProcessor.d.ts}

@@ -1,2 +1,2 @@
 import { ActionProcessorListResolver } from 'quidproquo-core';
-export declare const getContextListActionProcessor: ActionProcessorListResolver;
+export declare const getStreamCloseActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/core/stream/getStreamCloseActionProcessor.js

@@ -0,0 +1,10 @@
+import { actionResult, StreamActionType, } from 'quidproquo-core';
+const getProcessStreamClose = (qpqConfig) => {
+    return async ({ streamId }, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        streamRegistry.close(streamId);
+        return actionResult(undefined);
+    };
+};
+export const getStreamCloseActionProcessor = async (qpqConfig) => ({
+    [StreamActionType.Close]: getProcessStreamClose(qpqConfig),
+});

package/lib/esm/actionProcessor/core/stream/getStreamReadActionProcessor.d.ts

@@ -0,0 +1,2 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+export declare const getStreamReadActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/core/stream/getStreamReadActionProcessor.js

@@ -0,0 +1,10 @@
+import { actionResult, StreamActionType, } from 'quidproquo-core';
+const getProcessStreamRead = (qpqConfig) => {
+    return async ({ streamId, noWait }, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        const chunk = await streamRegistry.read(streamId, noWait);
+        return actionResult(chunk);
+    };
+};
+export const getStreamReadActionProcessor = async (qpqConfig) => ({
+    [StreamActionType.Read]: getProcessStreamRead(qpqConfig),
+});

package/lib/esm/actionProcessor/core/{config → stream}/index.d.ts

@@ -1,2 +1,2 @@
 import { ActionProcessorListResolver } from 'quidproquo-core';
-export declare const getConfigActionProcessor: ActionProcessorListResolver;
+export declare const getStreamActionProcessor: ActionProcessorListResolver;

package/lib/esm/actionProcessor/core/stream/index.js

@@ -0,0 +1,6 @@
+import { getStreamCloseActionProcessor } from './getStreamCloseActionProcessor';
+import { getStreamReadActionProcessor } from './getStreamReadActionProcessor';
+export const getStreamActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getStreamCloseActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getStreamReadActionProcessor(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/actionProcessor/webserver/index.js

@@ -1,4 +1,6 @@
-import { getDnsActionProcessor } from './dns';
+import { getWebserverActionProcessor as getJsWebserverActionProcessor } from 'quidproquo-actionprocessor-js';
+// The shared webserver processors (dns, ...) are owned by quidproquo-actionprocessor-js.
+// Node builds on top of js; it currently adds no node-specific webserver processors.
 export const getWebserverActionProcessor = async (qpqConfig, dynamicModuleLoader) => ({
-    ...(await getDnsActionProcessor(qpqConfig, dynamicModuleLoader)),
+    ...(await getJsWebserverActionProcessor(qpqConfig, dynamicModuleLoader)),
 });

package/lib/esm/dynamicActionProcessor/file/getFileDeleteActionProcessor.js

@@ -1,14 +1,13 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, FileDeleteErrorTypeEnum, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import { resolveFilePath } from './utils';
 const getProcessFileDelete = (qpqConfig, config) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepaths }) => {
         const deletedFiles = [];
         const errors = [];
         for (const filepath of filepaths) {
             try {
-                const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+                const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
                 await fs.unlink(fullPath);
                 deletedFiles.push(filepath);
             }
@@ -18,12 +17,16 @@ const getProcessFileDelete = (qpqConfig, config) => {
                     deletedFiles.push(filepath);
                 }
                 else {
-                    errors.push(`Failed to delete ${filepath}: ${error.message}`);
+                    errors.push({ filepath, error });
                 }
             }
         }
         if (errors.length > 0 && deletedFiles.length === 0) {
-            return actionResultError(ErrorTypeEnum.GenericError, `Failed to delete files: ${errors.join(', ')}`);
+            // EACCES maps to the same typed error the S3 processor returns for AccessDenied
+            if (errors.some(({ error }) => error.code === 'EACCES')) {
+                return actionResultError(FileDeleteErrorTypeEnum.AccessDenied, 'Access denied deleting files');
+            }
+            return actionResultError(ErrorTypeEnum.GenericError, `Failed to delete files: ${errors.map(({ filepath, error }) => `Failed to delete ${filepath}: ${error.message}`).join(', ')}`);
         }
         return actionResult(deletedFiles);
     };

package/lib/esm/dynamicActionProcessor/file/getFileExistsActionProcessor.js

@@ -1,17 +1,23 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, FileExistsErrorTypeEnum, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import { resolveFilePath } from './utils';
 const getProcessFileExists = (qpqConfig, config) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath }) => {
         try {
-            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
             try {
                 await fs.access(fullPath);
                 return actionResult(true);
             }
-            catch {
-                return actionResult(false);
+            catch (error) {
+                // Missing file is a definitive false; permission problems must surface.
+                if (error.code === 'ENOENT') {
+                    return actionResult(false);
+                }
+                if (error.code === 'EACCES') {
+                    return actionResultError(FileExistsErrorTypeEnum.AccessDenied, `Access denied checking file existence: ${filepath}`);
+                }
+                throw error;
             }
         }
         catch (error) {

package/lib/esm/dynamicActionProcessor/file/getFileGenerateTemporarySecureUrlActionProcessor.js

@@ -1,13 +1,12 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, } from 'quidproquo-core';
 import { createSecureUrlToken, getSecureUrlBaseUrl } from './secureUrlUtils';
 import { resolveFilePath } from './utils';
 const getProcessFileGenerateTemporarySecureUrl = (qpqConfig, config) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath, expirationMs }) => {
         try {
             // Create a token for download
             const token = createSecureUrlToken({
-                fullFilepath: resolveFilePath(config, serviceName, drive, filepath),
+                fullFilepath: resolveFilePath(config, qpqConfig, drive, filepath),
                 operation: 'download',
                 expiresAt: Date.now() + expirationMs,
             }, config.secureUrlSecret);

package/lib/esm/dynamicActionProcessor/file/getFileGenerateTemporaryUploadSecureUrlActionProcessor.js

@@ -1,14 +1,13 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, } from 'quidproquo-core';
 import { createSecureUrlToken, getSecureUrlBaseUrl } from './secureUrlUtils';
 import { resolveFilePath } from './utils';
 const getProcessFileGenerateTemporaryUploadSecureUrl = (qpqConfig, config) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath, expirationMs, contentType }) => {
         try {
             const expiresAt = Date.now() + expirationMs;
             // Create a token for upload
             const token = createSecureUrlToken({
-                fullFilepath: resolveFilePath(config, serviceName, drive, filepath),
+                fullFilepath: resolveFilePath(config, qpqConfig, drive, filepath),
                 operation: 'upload',
                 expiresAt,
                 contentType,

package/lib/esm/dynamicActionProcessor/file/getFileListDirectoryActionProcessor.js

@@ -1,12 +1,11 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileListDirectoryErrorTypeEnum, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { resolveFilePath } from './utils';
 const getProcessFileListDirectory = (config) => (qpqConfig) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, folderPath, maxFiles, pageToken }) => {
         try {
-            const fullPath = resolveFilePath(config, serviceName, drive, folderPath || '');
+            const fullPath = resolveFilePath(config, qpqConfig, drive, folderPath || '');
             // Read all entries in the directory
             const entries = await fs.readdir(fullPath, { withFileTypes: true });
             // Build file info list
@@ -35,13 +34,11 @@ const getProcessFileListDirectory = (config) => (qpqConfig) => {
             return actionResult(result);
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
-                return actionResultError(ErrorTypeEnum.NotFound, `Directory not found: ${folderPath}`);
-            }
-            if (error.code === 'ENOTDIR') {
-                return actionResultError(ErrorTypeEnum.GenericError, `Path is not a directory: ${folderPath}`);
-            }
-            return actionResultError(ErrorTypeEnum.GenericError, `Error listing directory: ${error.message}`);
+            return actionResultErrorFromCaughtError(error, {
+                ENOENT: () => actionResultError(FileListDirectoryErrorTypeEnum.DirectoryNotFound, `Directory not found: ${folderPath}`), // node fs code
+                ENOTDIR: () => actionResultError(FileListDirectoryErrorTypeEnum.NotADirectory, `Path is not a directory: ${folderPath}`), // node fs code
+                EACCES: () => actionResultError(FileListDirectoryErrorTypeEnum.AccessDenied, `Access denied listing directory: ${folderPath}`), // node fs code
+            });
         }
     };
 };

package/lib/esm/dynamicActionProcessor/file/getFileReadBinaryContentsActionProcessor.js

@@ -1,12 +1,11 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileReadBinaryContentsErrorTypeEnum, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { resolveFilePath } from './utils';
 const getProcessFileReadBinaryContents = (config) => (qpqConfig) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath }) => {
         try {
-            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
             const buffer = await fs.readFile(fullPath);
             // Convert Buffer to QPQBinaryData
             const binaryData = {
@@ -17,10 +16,9 @@ const getProcessFileReadBinaryContents = (config) => (qpqConfig) => {
             return actionResult(binaryData);
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
-                return actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`);
-            }
-            return actionResultError(ErrorTypeEnum.GenericError, `Error reading binary file: ${error.message}`);
+            return actionResultErrorFromCaughtError(error, {
+                ENOENT: () => actionResultError(FileReadBinaryContentsErrorTypeEnum.FileNotFound, `File not found: ${filepath}`), // node fs code
+            });
         }
     };
 };

package/lib/esm/dynamicActionProcessor/file/getFileReadObjectJsonActionProcessor.js

@@ -1,23 +1,19 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, ErrorTypeEnum, FileActionType, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import { resolveFilePath } from './utils';
 const getProcessFileReadObjectJson = (config) => (qpqConfig) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath }) => {
         try {
-            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
             const content = await fs.readFile(fullPath, 'utf8');
             const jsonObject = JSON.parse(content);
             return actionResult(jsonObject);
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
-                return actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`);
-            }
-            if (error instanceof SyntaxError) {
-                return actionResultError(ErrorTypeEnum.GenericError, `Invalid JSON in file: ${filepath}`);
-            }
-            return actionResultError(ErrorTypeEnum.GenericError, `Error reading JSON file: ${error.message}`);
+            return actionResultErrorFromCaughtError(error, {
+                ENOENT: () => actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`), // node fs code
+                SyntaxError: () => actionResultError(ErrorTypeEnum.GenericError, `Invalid JSON in file: ${filepath}`), // JSON.parse failure
+            });
         }
     };
 };

package/lib/esm/dynamicActionProcessor/file/getFileReadTextContentsActionProcessor.js

@@ -1,19 +1,17 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, ErrorTypeEnum, FileActionType, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import { resolveFilePath } from './utils';
 const getProcessFileReadTextContents = (qpqConfig, config) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath }) => {
         try {
-            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
             const content = await fs.readFile(fullPath, 'utf8');
             return actionResult(content);
         }
         catch (error) {
-            if (error.code === 'ENOENT') {
-                return actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`);
-            }
-            return actionResultError(ErrorTypeEnum.GenericError, `Error reading file: ${error.message}`);
+            return actionResultErrorFromCaughtError(error, {
+                ENOENT: () => actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`), // node fs code
+            });
         }
     };
 };

package/lib/esm/dynamicActionProcessor/file/getFileStreamOpenActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileStreamOpenActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileStreamOpenActionProcessor.js

@@ -0,0 +1,37 @@
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileStreamOpenErrorTypeEnum, } from 'quidproquo-core';
+import { randomUUID } from 'crypto';
+import * as fs from 'fs';
+import { resolveFilePath } from './utils';
+async function* textStreamIterator(stream) {
+    for await (const chunk of stream) {
+        yield typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    }
+}
+async function* binaryStreamIterator(stream) {
+    for await (const chunk of stream) {
+        const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        yield buffer.toString('base64');
+    }
+}
+const getProcessFileStreamOpen = (qpqConfig, config) => {
+    return async ({ drive, filepath, encoding, chunkSize }, session, actionProcessors, logger, updateSession, dynamicModuleLoader, streamRegistry) => {
+        try {
+            const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
+            const isText = encoding === 'text';
+            const highWaterMark = chunkSize ?? 65536;
+            const readStream = fs.createReadStream(fullPath, isText ? { encoding: 'utf8', highWaterMark } : { highWaterMark });
+            const streamId = `file-${randomUUID()}`;
+            const iterator = isText ? textStreamIterator(readStream) : binaryStreamIterator(readStream);
+            streamRegistry.register(streamId, iterator);
+            return actionResult({ id: streamId, encoding });
+        }
+        catch (error) {
+            return actionResultErrorFromCaughtError(error, {
+                ENOENT: () => actionResultError(FileStreamOpenErrorTypeEnum.FileNotFound, `File not found: ${filepath}`), // node fs code
+            });
+        }
+    };
+};
+export const getFileStreamOpenActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.StreamOpen]: getProcessFileStreamOpen(qpqConfig, config),
+});

package/lib/esm/dynamicActionProcessor/file/getFileWriteBinaryContentsActionProcessor.js

@@ -1,19 +1,26 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileWriteBinaryContentsErrorTypeEnum, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import { ensureParentDirectoryExists, resolveFilePath } from './utils';
 const getProcessFileWriteBinaryContents = (config) => (qpqConfig) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath, data }) => {
         try {
-            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
             await ensureParentDirectoryExists(fullPath);
             // Convert QPQBinaryData to Buffer
             const buffer = Buffer.from(data.base64Data, 'base64');
             await fs.writeFile(fullPath, buffer);
+            if (data.mimetype || data.contentDisposition) {
+                await fs.writeFile(`${fullPath}.qpqmeta.json`, JSON.stringify({
+                    mimetype: data.mimetype,
+                    contentDisposition: data.contentDisposition,
+                }));
+            }
             return actionResult(void 0);
         }
         catch (error) {
-            return actionResultError(ErrorTypeEnum.GenericError, `Error writing binary file: ${error.message}`);
+            return actionResultErrorFromCaughtError(error, {
+                EACCES: () => actionResultError(FileWriteBinaryContentsErrorTypeEnum.AccessDenied, `Access denied writing file: ${filepath}`), // node fs code
+            });
         }
     };
 };

package/lib/esm/dynamicActionProcessor/file/getFileWriteObjectJsonActionProcessor.js

@@ -1,18 +1,19 @@
-import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { actionResult, actionResultError, actionResultErrorFromCaughtError, FileActionType, FileWriteObjectJsonErrorTypeEnum, } from 'quidproquo-core';
 import * as fs from 'fs/promises';
 import { ensureParentDirectoryExists, resolveFilePath } from './utils';
 const getProcessFileWriteObjectJson = (config) => (qpqConfig) => {
-    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
     return async ({ drive, filepath, data }) => {
         try {
-            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const fullPath = resolveFilePath(config, qpqConfig, drive, filepath);
             await ensureParentDirectoryExists(fullPath);
             const jsonString = JSON.stringify(data, null, 2);
             await fs.writeFile(fullPath, jsonString, 'utf8');
             return actionResult(void 0);
         }
         catch (error) {
-            return actionResultError(ErrorTypeEnum.GenericError, `Error writing JSON file: ${error.message}`);
+            return actionResultErrorFromCaughtError(error, {
+                EACCES: () => actionResultError(FileWriteObjectJsonErrorTypeEnum.AccessDenied, `Access denied writing file: ${filepath}`), // node fs code
+            });
         }
     };
 };