@milaboratories/pframes-rs-serv 1.0.61 → 1.0.63

package/dist/export.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var fsStore = require('./fs-store.cjs');
+var handler = require('./handler.cjs');
+var serve = require('./serve.cjs');
+
+const HttpHelpers = {
+    createFsStore: async (options) => {
+        return await fsStore.FileSystemStore.init(options);
+    },
+    createRequestHandler: (options) => {
+        return handler.createRequestHandler(options);
+    },
+    createHttpServer: async (options) => {
+        return await serve.serve(options);
+    }
+};
+
+exports.HttpHelpers = HttpHelpers;
+//# sourceMappingURL=export.cjs.map

package/dist/export.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.cjs","sources":["../src/export.ts"],"sourcesContent":["import { RequestListener } from 'http';\nimport { FileSystemStore } from './fs-store';\nimport { createRequestHandler } from './handler';\nimport { serve } from './serve';\nimport { PFrameInternal } from '@milaboratories/pl-model-middle-layer';\n\nexport const HttpHelpers: PFrameInternal.HttpHelpers = {\n  createFsStore: async (\n    options: PFrameInternal.FsStoreOptions\n  ): Promise<PFrameInternal.ObjectStore> => {\n    return await FileSystemStore.init(options);\n  },\n  createRequestHandler: (\n    options: PFrameInternal.RequestHandlerOptions\n  ): RequestListener => {\n    return createRequestHandler(options);\n  },\n  createHttpServer: async (\n    options: PFrameInternal.HttpServerOptions\n  ): Promise<PFrameInternal.HttpServer> => {\n    return await serve(options);\n  }\n};\n"],"names":["FileSystemStore","createRequestHandler","serve"],"mappings":";;;;;;AAMO,MAAM,WAAW,GAA+B;AACrD,IAAA,aAAa,EAAE,OACb,OAAsC,KACC;AACvC,QAAA,OAAO,MAAMA,uBAAe,CAAC,IAAI,CAAC,OAAO,CAAC;IAC5C,CAAC;AACD,IAAA,oBAAoB,EAAE,CACpB,OAA6C,KAC1B;AACnB,QAAA,OAAOC,4BAAoB,CAAC,OAAO,CAAC;IACtC,CAAC;AACD,IAAA,gBAAgB,EAAE,OAChB,OAAyC,KACH;AACtC,QAAA,OAAO,MAAMC,WAAK,CAAC,OAAO,CAAC;IAC7B;;;;;"}

package/dist/export.d.ts

@@ -0,0 +1,3 @@
+import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+export declare const HttpHelpers: PFrameInternal.HttpHelpers;
+//# sourceMappingURL=export.d.ts.map

package/dist/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../src/export.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAEvE,eAAO,MAAM,WAAW,EAAE,cAAc,CAAC,WAgBxC,CAAC"}

package/dist/export.js

@@ -0,0 +1,18 @@
+import { FileSystemStore } from './fs-store.js';
+import { createRequestHandler } from './handler.js';
+import { serve } from './serve.js';
+
+const HttpHelpers = {
+    createFsStore: async (options) => {
+        return await FileSystemStore.init(options);
+    },
+    createRequestHandler: (options) => {
+        return createRequestHandler(options);
+    },
+    createHttpServer: async (options) => {
+        return await serve(options);
+    }
+};
+
+export { HttpHelpers };
+//# sourceMappingURL=export.js.map

package/dist/export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.js","sources":["../src/export.ts"],"sourcesContent":["import { RequestListener } from 'http';\nimport { FileSystemStore } from './fs-store';\nimport { createRequestHandler } from './handler';\nimport { serve } from './serve';\nimport { PFrameInternal } from '@milaboratories/pl-model-middle-layer';\n\nexport const HttpHelpers: PFrameInternal.HttpHelpers = {\n  createFsStore: async (\n    options: PFrameInternal.FsStoreOptions\n  ): Promise<PFrameInternal.ObjectStore> => {\n    return await FileSystemStore.init(options);\n  },\n  createRequestHandler: (\n    options: PFrameInternal.RequestHandlerOptions\n  ): RequestListener => {\n    return createRequestHandler(options);\n  },\n  createHttpServer: async (\n    options: PFrameInternal.HttpServerOptions\n  ): Promise<PFrameInternal.HttpServer> => {\n    return await serve(options);\n  }\n};\n"],"names":[],"mappings":";;;;AAMO,MAAM,WAAW,GAA+B;AACrD,IAAA,aAAa,EAAE,OACb,OAAsC,KACC;AACvC,QAAA,OAAO,MAAM,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC;IAC5C,CAAC;AACD,IAAA,oBAAoB,EAAE,CACpB,OAA6C,KAC1B;AACnB,QAAA,OAAO,oBAAoB,CAAC,OAAO,CAAC;IACtC,CAAC;AACD,IAAA,gBAAgB,EAAE,OAChB,OAAyC,KACH;AACtC,QAAA,OAAO,MAAM,KAAK,CAAC,OAAO,CAAC;IAC7B;;;;;"}

package/dist/fs-store.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var promises = require('node:fs/promises');
+var node_path = require('node:path');
+var plModelMiddleLayer = require('@milaboratories/pl-model-middle-layer');
+var plModelCommon = require('@milaboratories/pl-model-common');
+
+/** Object store for serving files from a local directory */
+class FileSystemStore extends plModelMiddleLayer.PFrameInternal.ObjectStore {
+    rootDir;
+    constructor(options) {
+        super(options);
+        this.rootDir = options.rootDir;
+    }
+    static async init(options) {
+        const resolvedRootDir = node_path.resolve(options.rootDir);
+        const rootStats = await promises.stat(resolvedRootDir).catch(() => {
+            throw new Error(`File system store root directory does not exist: ${resolvedRootDir}`);
+        });
+        if (!rootStats.isDirectory()) {
+            throw new Error(`File system store root path is not a directory: ${resolvedRootDir}`);
+        }
+        return new FileSystemStore({
+            ...options,
+            rootDir: resolvedRootDir
+        });
+    }
+    async request(filename, params) {
+        let file;
+        try {
+            const path = node_path.join(this.rootDir, filename);
+            file = await promises.open(path, 'r');
+        }
+        catch (error) {
+            this.logger('error', `File system store failed to open file ${filename}: ${plModelCommon.ensureError(error)}`);
+            return await params.callback({ type: 'NotFound' });
+        }
+        try {
+            let size;
+            try {
+                ({ size } = await file.stat());
+            }
+            catch (error) {
+                this.logger('error', `File system store failed to get size of file ${filename}: ${plModelCommon.ensureError(error)}`);
+                return await params.callback({ type: 'InternalError' });
+            }
+            const range = this.translate(size, params.range);
+            if (!range) {
+                return await params.callback({ type: 'RangeNotSatisfiable', size });
+            }
+            if (params.method === 'HEAD') {
+                return await params.callback({ type: 'Ok', size, range });
+            }
+            let data;
+            try {
+                data = node_fs.createReadStream('ignored', {
+                    fd: file.fd,
+                    autoClose: false,
+                    start: range.start,
+                    end: range.end,
+                    signal: params.signal
+                });
+                this.logger('info', `File system store created read stream for ${filename}[${range.start}..=${range.end}]`);
+            }
+            catch (error) {
+                this.logger('error', `File system store failed to create read stream for ${filename}[${range.start}..=${range.end}]: ${plModelCommon.ensureError(error)}`);
+                return await params.callback({ type: 'InternalError' });
+            }
+            return await params
+                .callback({ type: 'Ok', size, range, data })
+                .catch(() => { });
+        }
+        finally {
+            await file.close();
+        }
+    }
+}
+
+exports.FileSystemStore = FileSystemStore;
+//# sourceMappingURL=fs-store.cjs.map

package/dist/fs-store.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-store.cjs","sources":["../src/fs-store.ts"],"sourcesContent":["import type { Readable } from 'node:stream';\nimport { createReadStream } from 'node:fs';\nimport { stat, open, type FileHandle } from 'node:fs/promises';\nimport { join, resolve } from 'node:path';\nimport { PFrameInternal } from '@milaboratories/pl-model-middle-layer';\nimport { ensureError } from '@milaboratories/pl-model-common';\n\n/** Object store for serving files from a local directory */\nexport class FileSystemStore extends PFrameInternal.ObjectStore {\n  private readonly rootDir: string;\n\n  private constructor(options: PFrameInternal.FsStoreOptions) {\n    super(options);\n\n    this.rootDir = options.rootDir;\n  }\n\n  static async init(\n    options: PFrameInternal.FsStoreOptions\n  ): Promise<FileSystemStore> {\n    const resolvedRootDir = resolve(options.rootDir);\n\n    const rootStats = await stat(resolvedRootDir).catch(() => {\n      throw new Error(\n        `File system store root directory does not exist: ${resolvedRootDir}`\n      );\n    });\n    if (!rootStats.isDirectory()) {\n      throw new Error(\n        `File system store root path is not a directory: ${resolvedRootDir}`\n      );\n    }\n\n    return new FileSystemStore({\n      ...options,\n      rootDir: resolvedRootDir\n    });\n  }\n\n  override async request(\n    filename: PFrameInternal.ParquetFileName,\n    params: {\n      method: PFrameInternal.HttpMethod;\n      range?: PFrameInternal.HttpRange;\n      signal: AbortSignal;\n      callback: (response: PFrameInternal.ObjectStoreResponse) => Promise<void>;\n    }\n  ): Promise<void> {\n    let file: FileHandle;\n    try {\n      const path = join(this.rootDir, filename);\n      file = await open(path, 'r');\n    } catch (error: unknown) {\n      this.logger(\n        'error',\n        `File system store failed to open file ${filename}: ${ensureError(error)}`\n      );\n      return await params.callback({ type: 'NotFound' });\n    }\n\n    try {\n      let size: number;\n      try {\n        ({ size } = await file.stat());\n      } catch (error: unknown) {\n        this.logger(\n          'error',\n          `File system store failed to get size of file ${filename}: ${ensureError(error)}`\n        );\n        return await params.callback({ type: 'InternalError' });\n      }\n\n      const range = this.translate(size, params.range);\n      if (!range) {\n        return await params.callback({ type: 'RangeNotSatisfiable', size });\n      }\n\n      if (params.method === 'HEAD') {\n        return await params.callback({ type: 'Ok', size, range });\n      }\n\n      let data: Readable;\n      try {\n        data = createReadStream('ignored', {\n          fd: file.fd,\n          autoClose: false,\n          start: range.start,\n          end: range.end,\n          signal: params.signal\n        });\n        this.logger(\n          'info',\n          `File system store created read stream for ${filename}[${range.start}..=${range.end}]`\n        );\n      } catch (error: unknown) {\n        this.logger(\n          'error',\n          `File system store failed to create read stream for ${filename}[${range.start}..=${range.end}]: ${ensureError(error)}`\n        );\n        return await params.callback({ type: 'InternalError' });\n      }\n\n      return await params\n        .callback({ type: 'Ok', size, range, data })\n        .catch(() => {});\n    } finally {\n      await file.close();\n    }\n  }\n}\n"],"names":["PFrameInternal","resolve","stat","join","open","ensureError","createReadStream"],"mappings":"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"}

package/dist/fs-store.d.ts

@@ -0,0 +1,14 @@
+import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+/** Object store for serving files from a local directory */
+export declare class FileSystemStore extends PFrameInternal.ObjectStore {
+    private readonly rootDir;
+    private constructor();
+    static init(options: PFrameInternal.FsStoreOptions): Promise<FileSystemStore>;
+    request(filename: PFrameInternal.ParquetFileName, params: {
+        method: PFrameInternal.HttpMethod;
+        range?: PFrameInternal.HttpRange;
+        signal: AbortSignal;
+        callback: (response: PFrameInternal.ObjectStoreResponse) => Promise<void>;
+    }): Promise<void>;
+}
+//# sourceMappingURL=fs-store.d.ts.map

package/dist/fs-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-store.d.ts","sourceRoot":"","sources":["../src/fs-store.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAGvE,4DAA4D;AAC5D,qBAAa,eAAgB,SAAQ,cAAc,CAAC,WAAW;IAC7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO;WAMM,IAAI,CACf,OAAO,EAAE,cAAc,CAAC,cAAc,GACrC,OAAO,CAAC,eAAe,CAAC;IAoBZ,OAAO,CACpB,QAAQ,EAAE,cAAc,CAAC,eAAe,EACxC,MAAM,EAAE;QACN,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC;QAClC,KAAK,CAAC,EAAE,cAAc,CAAC,SAAS,CAAC;QACjC,MAAM,EAAE,WAAW,CAAC;QACpB,QAAQ,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KAC3E,GACA,OAAO,CAAC,IAAI,CAAC;CA8DjB"}

package/dist/fs-store.js

@@ -0,0 +1,79 @@
+import { createReadStream } from 'node:fs';
+import { stat, open } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import { ensureError } from '@milaboratories/pl-model-common';
+
+/** Object store for serving files from a local directory */
+class FileSystemStore extends PFrameInternal.ObjectStore {
+    rootDir;
+    constructor(options) {
+        super(options);
+        this.rootDir = options.rootDir;
+    }
+    static async init(options) {
+        const resolvedRootDir = resolve(options.rootDir);
+        const rootStats = await stat(resolvedRootDir).catch(() => {
+            throw new Error(`File system store root directory does not exist: ${resolvedRootDir}`);
+        });
+        if (!rootStats.isDirectory()) {
+            throw new Error(`File system store root path is not a directory: ${resolvedRootDir}`);
+        }
+        return new FileSystemStore({
+            ...options,
+            rootDir: resolvedRootDir
+        });
+    }
+    async request(filename, params) {
+        let file;
+        try {
+            const path = join(this.rootDir, filename);
+            file = await open(path, 'r');
+        }
+        catch (error) {
+            this.logger('error', `File system store failed to open file ${filename}: ${ensureError(error)}`);
+            return await params.callback({ type: 'NotFound' });
+        }
+        try {
+            let size;
+            try {
+                ({ size } = await file.stat());
+            }
+            catch (error) {
+                this.logger('error', `File system store failed to get size of file ${filename}: ${ensureError(error)}`);
+                return await params.callback({ type: 'InternalError' });
+            }
+            const range = this.translate(size, params.range);
+            if (!range) {
+                return await params.callback({ type: 'RangeNotSatisfiable', size });
+            }
+            if (params.method === 'HEAD') {
+                return await params.callback({ type: 'Ok', size, range });
+            }
+            let data;
+            try {
+                data = createReadStream('ignored', {
+                    fd: file.fd,
+                    autoClose: false,
+                    start: range.start,
+                    end: range.end,
+                    signal: params.signal
+                });
+                this.logger('info', `File system store created read stream for ${filename}[${range.start}..=${range.end}]`);
+            }
+            catch (error) {
+                this.logger('error', `File system store failed to create read stream for ${filename}[${range.start}..=${range.end}]: ${ensureError(error)}`);
+                return await params.callback({ type: 'InternalError' });
+            }
+            return await params
+                .callback({ type: 'Ok', size, range, data })
+                .catch(() => { });
+        }
+        finally {
+            await file.close();
+        }
+    }
+}
+
+export { FileSystemStore };
+//# sourceMappingURL=fs-store.js.map

package/dist/fs-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-store.js","sources":["../src/fs-store.ts"],"sourcesContent":["import type { Readable } from 'node:stream';\nimport { createReadStream } from 'node:fs';\nimport { stat, open, type FileHandle } from 'node:fs/promises';\nimport { join, resolve } from 'node:path';\nimport { PFrameInternal } from '@milaboratories/pl-model-middle-layer';\nimport { ensureError } from '@milaboratories/pl-model-common';\n\n/** Object store for serving files from a local directory */\nexport class FileSystemStore extends PFrameInternal.ObjectStore {\n  private readonly rootDir: string;\n\n  private constructor(options: PFrameInternal.FsStoreOptions) {\n    super(options);\n\n    this.rootDir = options.rootDir;\n  }\n\n  static async init(\n    options: PFrameInternal.FsStoreOptions\n  ): Promise<FileSystemStore> {\n    const resolvedRootDir = resolve(options.rootDir);\n\n    const rootStats = await stat(resolvedRootDir).catch(() => {\n      throw new Error(\n        `File system store root directory does not exist: ${resolvedRootDir}`\n      );\n    });\n    if (!rootStats.isDirectory()) {\n      throw new Error(\n        `File system store root path is not a directory: ${resolvedRootDir}`\n      );\n    }\n\n    return new FileSystemStore({\n      ...options,\n      rootDir: resolvedRootDir\n    });\n  }\n\n  override async request(\n    filename: PFrameInternal.ParquetFileName,\n    params: {\n      method: PFrameInternal.HttpMethod;\n      range?: PFrameInternal.HttpRange;\n      signal: AbortSignal;\n      callback: (response: PFrameInternal.ObjectStoreResponse) => Promise<void>;\n    }\n  ): Promise<void> {\n    let file: FileHandle;\n    try {\n      const path = join(this.rootDir, filename);\n      file = await open(path, 'r');\n    } catch (error: unknown) {\n      this.logger(\n        'error',\n        `File system store failed to open file ${filename}: ${ensureError(error)}`\n      );\n      return await params.callback({ type: 'NotFound' });\n    }\n\n    try {\n      let size: number;\n      try {\n        ({ size } = await file.stat());\n      } catch (error: unknown) {\n        this.logger(\n          'error',\n          `File system store failed to get size of file ${filename}: ${ensureError(error)}`\n        );\n        return await params.callback({ type: 'InternalError' });\n      }\n\n      const range = this.translate(size, params.range);\n      if (!range) {\n        return await params.callback({ type: 'RangeNotSatisfiable', size });\n      }\n\n      if (params.method === 'HEAD') {\n        return await params.callback({ type: 'Ok', size, range });\n      }\n\n      let data: Readable;\n      try {\n        data = createReadStream('ignored', {\n          fd: file.fd,\n          autoClose: false,\n          start: range.start,\n          end: range.end,\n          signal: params.signal\n        });\n        this.logger(\n          'info',\n          `File system store created read stream for ${filename}[${range.start}..=${range.end}]`\n        );\n      } catch (error: unknown) {\n        this.logger(\n          'error',\n          `File system store failed to create read stream for ${filename}[${range.start}..=${range.end}]: ${ensureError(error)}`\n        );\n        return await params.callback({ type: 'InternalError' });\n      }\n\n      return await params\n        .callback({ type: 'Ok', size, range, data })\n        .catch(() => {});\n    } finally {\n      await file.close();\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/handler.cjs

@@ -0,0 +1,157 @@
+'use strict';
+
+var promises = require('node:stream/promises');
+var node_crypto = require('node:crypto');
+var filename = require('./utils/filename.cjs');
+var etag = require('./utils/etag.cjs');
+var headers = require('./utils/headers.cjs');
+var options = require('./utils/options.cjs');
+var range = require('./utils/range.cjs');
+var method = require('./utils/method.cjs');
+var status = require('./utils/status.cjs');
+
+/** Main request handler for parquet files */
+async function handleRequest(request, response, store) {
+    // RFC 9110 section 6.6.1: Date header should be present in all responses
+    response.sendDate = true;
+    // RFC 9110 section 8.6: Content-Length 0 as default for error responses
+    response.strictContentLength = true;
+    response.setHeader(headers.HeaderName.ContentLength, 0);
+    // Note: setting Content-Length disables Node.js default Transfer-Encoding: chunked
+    // RFC 9111 section 5.2: Cache-Control header with public allows to cache authenticated responses
+    response.setHeader(headers.HeaderName.CacheControl, headers.HeaderValue.CacheControl);
+    // RFC 9110 section 15.5.6: Method not allowed
+    const method$1 = request.method;
+    if (!method.isGetOrHead(method$1)) {
+        response.setHeader(headers.HeaderName.Allow, headers.HeaderValue.Allow);
+        return void response.writeHead(status.StatusCode.MethodNotAllowed).end();
+    }
+    const filename$1 = filename.getFilenameFromUrl(request);
+    if (filename$1 === null) {
+        return void response.writeHead(status.StatusCode.Gone).end();
+    }
+    // From now on we are sure that the response would be a Parquet file
+    response.setHeader(headers.HeaderName.AcceptRanges, headers.HeaderValue.AcceptRanges);
+    response.setHeader(headers.HeaderName.ContentType, headers.HeaderValue.ContentType);
+    // RFC 9110 section 8.8.3: ETag header is used for cache versioning
+    const etag$1 = etag.createETag(filename$1);
+    // RFC 9110 section 8.8.2: Last-Modified header field for cache validation
+    const mtime = new Date(0); // Using fake fixed date since files are immutable
+    // RFC 9111 section 5.2: Cache-Control header with public allows to cache authenticated responses
+    response.setHeader(headers.HeaderName.CacheControl, headers.HeaderValue.CacheControl);
+    response.setHeader(headers.HeaderName.ETag, etag$1);
+    response.setHeader(headers.HeaderName.LastModified, mtime.toUTCString());
+    const options$1 = new options.Options(request);
+    // RFC 9110 section 13.1.1: If-Match precondition evaluation
+    // RFC 9110 section 13.1.4: If-Unmodified-Since precondition evaluation
+    if (options$1.preconditionFailed(etag$1, mtime)) {
+        return void response.writeHead(status.StatusCode.PreconditionFailed).end();
+    }
+    // RFC 9110 section 13.1.2: If-None-Match precondition evaluation
+    // RFC 9110 section 13.1.3: If-Modified-Since precondition evaluation
+    else if (options$1.notModified(etag$1, mtime)) {
+        return void response.writeHead(status.StatusCode.NotModified).end();
+    }
+    const range$1 = range.parseRange(request);
+    if (range$1 === null) {
+        return void response.writeHead(status.StatusCode.BadRequest).end();
+    }
+    const abortController = new AbortController();
+    request.on('close', () => abortController.abort());
+    const signal = abortController.signal;
+    store.request(filename$1, {
+        method: 'GET',
+        range: range$1,
+        signal,
+        // pipeline automatically destroys the streams if they were not gracefully closed
+        callback: async (result) => {
+            if (response.destroyed)
+                return void response.destroy();
+            switch (result.type) {
+                case 'InternalError':
+                    // object store encountered network error, retry by client can help
+                    return void response.writeHead(status.StatusCode.InternalServerError).end();
+                case 'NotFound':
+                    // RFC 9110 section 15.4.5: Not found
+                    return void response.writeHead(status.StatusCode.NotFound).end();
+                case 'RangeNotSatisfiable':
+                    // RFC 9110 section 15.5.17: Range not satisfiable
+                    response.setHeader(headers.HeaderName.ContentRange, `bytes */${result.size}`);
+                    return void response.writeHead(status.StatusCode.RangeNotSatisfiable).end();
+            }
+            if (method.isGet(method$1) && !result.data) {
+                // object store implementation is incorrect, retry by client cannot help
+                return void response.writeHead(status.StatusCode.GatewayTimeout).end();
+            }
+            if (range$1) {
+                // RFC 9110 section 14.4: Partial content response
+                response.setHeader(headers.HeaderName.ContentLength, result.range.end - result.range.start + 1);
+                response.setHeader(headers.HeaderName.ContentRange, `bytes ${result.range.start}-${result.range.end}/${result.size}`);
+                response.writeHead(status.StatusCode.PartialContent);
+            }
+            else {
+                // RFC 9110 section 15.3.1: OK response
+                response.setHeader(headers.HeaderName.ContentLength, result.size);
+                response.writeHead(status.StatusCode.Ok);
+            }
+            // RFC 9110 section 9.3.2: HEAD method must not return message body
+            if (method.isHead(method$1)) {
+                return void response.end();
+            }
+            return await promises.pipeline(result.data, response, { signal }).catch(() => {
+                // Pipeline errors are expected when request is aborted or connection is lost
+                // Response head was already written, so we can't change status code
+                // Just mute the error - pipeline destroys the response stream
+            });
+        }
+    });
+}
+/**
+ * Create a request handler for serving files from an object store
+ * compatible with HTTP/1.1 as defined in RFC 9110 and RFC 9111:
+ * - <https://datatracker.ietf.org/doc/html/rfc9110>
+ * - <https://datatracker.ietf.org/doc/html/rfc9111>
+ *
+ * Accepts only paths of the form `/<filename>.parquet`, returns 404 otherwise
+ * Assumes that files are immutable (and sets cache headers accordingly)
+ */
+function createRequestHandler(options) {
+    const { store } = options;
+    return (request, response) => void handleRequest(request, response, store);
+}
+/** Request authorization middleware */
+function authorizeRequest(request, response, handler, authHeader) {
+    // RFC 9110 section 6.6.1: Date header should be present in all responses
+    response.sendDate = true;
+    // RFC 9110 section 8.6: Content-Length 0 as default for error responses
+    response.strictContentLength = true;
+    response.setHeader(headers.HeaderName.ContentLength, 0);
+    // Note: setting Content-Length disables Node.js default Transfer-Encoding: chunked
+    const actualHeader = request.headers['authorization'];
+    // Early length check to avoid unnecessary processing
+    if (!actualHeader || actualHeader.length !== authHeader.length) {
+        // RFC 9110 section 11.6.1: WWW-Authenticate header field
+        response.setHeader(headers.HeaderName.WWWAuthenticate, headers.HeaderValue.WWWAuthenticate);
+        return void response.writeHead(status.StatusCode.Unauthorized).end();
+    }
+    // Use timing-safe comparison to prevent timing attacks
+    // <https://developers.cloudflare.com/workers/examples/protect-against-timing-attacks/>
+    const encoder = new TextEncoder();
+    const receivedBuffer = encoder.encode(actualHeader);
+    const expectedBuffer = encoder.encode(authHeader);
+    if (receivedBuffer.byteLength !== expectedBuffer.byteLength ||
+        !node_crypto.timingSafeEqual(receivedBuffer, expectedBuffer)) {
+        response.setHeader(headers.HeaderName.WWWAuthenticate, headers.HeaderValue.WWWAuthenticate);
+        return void response.writeHead(status.StatusCode.Unauthorized).end();
+    }
+    return handler(request, response);
+}
+/** Apply Bearer token authorization to @param handler */
+function authorizeRequestHandler(handler, authToken) {
+    const authHeader = `Bearer ${authToken}`;
+    return (request, response) => authorizeRequest(request, response, handler, authHeader);
+}
+
+exports.authorizeRequestHandler = authorizeRequestHandler;
+exports.createRequestHandler = createRequestHandler;
+//# sourceMappingURL=handler.cjs.map

package/dist/handler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.cjs","sources":["../src/handler.ts"],"sourcesContent":["import type {\n  IncomingMessage,\n  RequestListener,\n  ServerResponse\n} from 'node:http';\nimport { pipeline } from 'node:stream/promises';\nimport { timingSafeEqual } from 'node:crypto';\nimport type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';\nimport {\n  createETag,\n  getFilenameFromUrl,\n  parseRange,\n  isGetOrHead,\n  isHead,\n  Options,\n  StatusCode,\n  HeaderName,\n  HeaderValue,\n  isGet\n} from './utils';\n\n/** Main request handler for parquet files */\nasync function handleRequest(\n  request: IncomingMessage,\n  response: ServerResponse,\n  store: PFrameInternal.ObjectStore\n): Promise<void> {\n  // RFC 9110 section 6.6.1: Date header should be present in all responses\n  response.sendDate = true;\n  // RFC 9110 section 8.6: Content-Length 0 as default for error responses\n  response.strictContentLength = true;\n  response.setHeader(HeaderName.ContentLength, 0);\n  // Note: setting Content-Length disables Node.js default Transfer-Encoding: chunked\n\n  // RFC 9111 section 5.2: Cache-Control header with public allows to cache authenticated responses\n  response.setHeader(HeaderName.CacheControl, HeaderValue.CacheControl);\n\n  // RFC 9110 section 15.5.6: Method not allowed\n  const method = request.method;\n  if (!isGetOrHead(method)) {\n    response.setHeader(HeaderName.Allow, HeaderValue.Allow);\n    return void response.writeHead(StatusCode.MethodNotAllowed).end();\n  }\n\n  const filename = getFilenameFromUrl(request);\n  if (filename === null) {\n    return void response.writeHead(StatusCode.Gone).end();\n  }\n\n  // From now on we are sure that the response would be a Parquet file\n  response.setHeader(HeaderName.AcceptRanges, HeaderValue.AcceptRanges);\n  response.setHeader(HeaderName.ContentType, HeaderValue.ContentType);\n\n  // RFC 9110 section 8.8.3: ETag header is used for cache versioning\n  const etag = createETag(filename);\n  // RFC 9110 section 8.8.2: Last-Modified header field for cache validation\n  const mtime = new Date(0); // Using fake fixed date since files are immutable\n  // RFC 9111 section 5.2: Cache-Control header with public allows to cache authenticated responses\n  response.setHeader(HeaderName.CacheControl, HeaderValue.CacheControl);\n  response.setHeader(HeaderName.ETag, etag);\n  response.setHeader(HeaderName.LastModified, mtime.toUTCString());\n\n  const options = new Options(request);\n  // RFC 9110 section 13.1.1: If-Match precondition evaluation\n  // RFC 9110 section 13.1.4: If-Unmodified-Since precondition evaluation\n  if (options.preconditionFailed(etag, mtime)) {\n    return void response.writeHead(StatusCode.PreconditionFailed).end();\n  }\n  // RFC 9110 section 13.1.2: If-None-Match precondition evaluation\n  // RFC 9110 section 13.1.3: If-Modified-Since precondition evaluation\n  else if (options.notModified(etag, mtime)) {\n    return void response.writeHead(StatusCode.NotModified).end();\n  }\n\n  const range = parseRange(request);\n  if (range === null) {\n    return void response.writeHead(StatusCode.BadRequest).end();\n  }\n\n  const abortController = new AbortController();\n  request.on('close', () => abortController.abort());\n  const signal = abortController.signal;\n\n  store.request(filename, {\n    method: 'GET',\n    range,\n    signal,\n    // pipeline automatically destroys the streams if they were not gracefully closed\n    callback: async (result) => {\n      if (response.destroyed) return void response.destroy();\n\n      switch (result.type) {\n        case 'InternalError':\n          // object store encountered network error, retry by client can help\n          return void response.writeHead(StatusCode.InternalServerError).end();\n        case 'NotFound':\n          // RFC 9110 section 15.4.5: Not found\n          return void response.writeHead(StatusCode.NotFound).end();\n        case 'RangeNotSatisfiable':\n          // RFC 9110 section 15.5.17: Range not satisfiable\n          response.setHeader(HeaderName.ContentRange, `bytes */${result.size}`);\n          return void response.writeHead(StatusCode.RangeNotSatisfiable).end();\n        case 'Ok':\n          break;\n      }\n\n      if (isGet(method) && !result.data) {\n        // object store implementation is incorrect, retry by client cannot help\n        return void response.writeHead(StatusCode.GatewayTimeout).end();\n      }\n\n      if (range) {\n        // RFC 9110 section 14.4: Partial content response\n        response.setHeader(\n          HeaderName.ContentLength,\n          result.range.end - result.range.start + 1\n        );\n        response.setHeader(\n          HeaderName.ContentRange,\n          `bytes ${result.range.start}-${result.range.end}/${result.size}`\n        );\n        response.writeHead(StatusCode.PartialContent);\n      } else {\n        // RFC 9110 section 15.3.1: OK response\n        response.setHeader(HeaderName.ContentLength, result.size);\n        response.writeHead(StatusCode.Ok);\n      }\n\n      // RFC 9110 section 9.3.2: HEAD method must not return message body\n      if (isHead(method)) {\n        return void response.end();\n      }\n\n      return await pipeline(result.data!, response, { signal }).catch(() => {\n        // Pipeline errors are expected when request is aborted or connection is lost\n        // Response head was already written, so we can't change status code\n        // Just mute the error - pipeline destroys the response stream\n      });\n    }\n  });\n}\n\n/**\n * Create a request handler for serving files from an object store\n * compatible with HTTP/1.1 as defined in RFC 9110 and RFC 9111:\n * - <https://datatracker.ietf.org/doc/html/rfc9110>\n * - <https://datatracker.ietf.org/doc/html/rfc9111>\n *\n * Accepts only paths of the form `/<filename>.parquet`, returns 404 otherwise\n * Assumes that files are immutable (and sets cache headers accordingly)\n */\nexport function createRequestHandler(\n  options: PFrameInternal.RequestHandlerOptions\n): RequestListener {\n  const { store } = options;\n  return (request, response) => void handleRequest(request, response, store);\n}\n\n/** Request authorization middleware */\nfunction authorizeRequest(\n  request: IncomingMessage,\n  response: ServerResponse,\n  handler: RequestListener,\n  authHeader: string\n): void {\n  // RFC 9110 section 6.6.1: Date header should be present in all responses\n  response.sendDate = true;\n  // RFC 9110 section 8.6: Content-Length 0 as default for error responses\n  response.strictContentLength = true;\n  response.setHeader(HeaderName.ContentLength, 0);\n  // Note: setting Content-Length disables Node.js default Transfer-Encoding: chunked\n\n  const actualHeader = request.headers['authorization'];\n\n  // Early length check to avoid unnecessary processing\n  if (!actualHeader || actualHeader.length !== authHeader.length) {\n    // RFC 9110 section 11.6.1: WWW-Authenticate header field\n    response.setHeader(HeaderName.WWWAuthenticate, HeaderValue.WWWAuthenticate);\n    return void response.writeHead(StatusCode.Unauthorized).end();\n  }\n\n  // Use timing-safe comparison to prevent timing attacks\n  // <https://developers.cloudflare.com/workers/examples/protect-against-timing-attacks/>\n  const encoder = new TextEncoder();\n  const receivedBuffer = encoder.encode(actualHeader);\n  const expectedBuffer = encoder.encode(authHeader);\n\n  if (\n    receivedBuffer.byteLength !== expectedBuffer.byteLength ||\n    !timingSafeEqual(receivedBuffer, expectedBuffer)\n  ) {\n    response.setHeader(HeaderName.WWWAuthenticate, HeaderValue.WWWAuthenticate);\n    return void response.writeHead(StatusCode.Unauthorized).end();\n  }\n\n  return handler(request, response);\n}\n\n/** Apply Bearer token authorization to @param handler */\nexport function authorizeRequestHandler(\n  handler: RequestListener,\n  authToken: PFrameInternal.HttpAuthorizationToken\n): RequestListener {\n  const authHeader = `Bearer ${authToken}`;\n  return (request, response) =>\n    authorizeRequest(request, response, handler, authHeader);\n}\n"],"names":["HeaderName","HeaderValue","method","isGetOrHead","StatusCode","filename","getFilenameFromUrl","etag","createETag","options","Options","range","parseRange","isGet","isHead","pipeline","timingSafeEqual"],"mappings":"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"}

package/dist/handler.d.ts

@@ -0,0 +1,15 @@
+import type { RequestListener } from 'node:http';
+import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+/**
+ * Create a request handler for serving files from an object store
+ * compatible with HTTP/1.1 as defined in RFC 9110 and RFC 9111:
+ * - <https://datatracker.ietf.org/doc/html/rfc9110>
+ * - <https://datatracker.ietf.org/doc/html/rfc9111>
+ *
+ * Accepts only paths of the form `/<filename>.parquet`, returns 404 otherwise
+ * Assumes that files are immutable (and sets cache headers accordingly)
+ */
+export declare function createRequestHandler(options: PFrameInternal.RequestHandlerOptions): RequestListener;
+/** Apply Bearer token authorization to @param handler */
+export declare function authorizeRequestHandler(handler: RequestListener, authToken: PFrameInternal.HttpAuthorizationToken): RequestListener;
+//# sourceMappingURL=handler.d.ts.map

package/dist/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../src/handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,eAAe,EAEhB,MAAM,WAAW,CAAC;AAGnB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAuI5E;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,cAAc,CAAC,qBAAqB,GAC5C,eAAe,CAGjB;AA0CD,yDAAyD;AACzD,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,cAAc,CAAC,sBAAsB,GAC/C,eAAe,CAIjB"}

package/dist/handler.js

@@ -0,0 +1,154 @@
+import { pipeline } from 'node:stream/promises';
+import { timingSafeEqual } from 'node:crypto';
+import { getFilenameFromUrl } from './utils/filename.js';
+import { createETag } from './utils/etag.js';
+import { HeaderName, HeaderValue } from './utils/headers.js';
+import { Options } from './utils/options.js';
+import { parseRange } from './utils/range.js';
+import { isGetOrHead, isGet, isHead } from './utils/method.js';
+import { StatusCode } from './utils/status.js';
+
+/** Main request handler for parquet files */
+async function handleRequest(request, response, store) {
+    // RFC 9110 section 6.6.1: Date header should be present in all responses
+    response.sendDate = true;
+    // RFC 9110 section 8.6: Content-Length 0 as default for error responses
+    response.strictContentLength = true;
+    response.setHeader(HeaderName.ContentLength, 0);
+    // Note: setting Content-Length disables Node.js default Transfer-Encoding: chunked
+    // RFC 9111 section 5.2: Cache-Control header with public allows to cache authenticated responses
+    response.setHeader(HeaderName.CacheControl, HeaderValue.CacheControl);
+    // RFC 9110 section 15.5.6: Method not allowed
+    const method = request.method;
+    if (!isGetOrHead(method)) {
+        response.setHeader(HeaderName.Allow, HeaderValue.Allow);
+        return void response.writeHead(StatusCode.MethodNotAllowed).end();
+    }
+    const filename = getFilenameFromUrl(request);
+    if (filename === null) {
+        return void response.writeHead(StatusCode.Gone).end();
+    }
+    // From now on we are sure that the response would be a Parquet file
+    response.setHeader(HeaderName.AcceptRanges, HeaderValue.AcceptRanges);
+    response.setHeader(HeaderName.ContentType, HeaderValue.ContentType);
+    // RFC 9110 section 8.8.3: ETag header is used for cache versioning
+    const etag = createETag(filename);
+    // RFC 9110 section 8.8.2: Last-Modified header field for cache validation
+    const mtime = new Date(0); // Using fake fixed date since files are immutable
+    // RFC 9111 section 5.2: Cache-Control header with public allows to cache authenticated responses
+    response.setHeader(HeaderName.CacheControl, HeaderValue.CacheControl);
+    response.setHeader(HeaderName.ETag, etag);
+    response.setHeader(HeaderName.LastModified, mtime.toUTCString());
+    const options = new Options(request);
+    // RFC 9110 section 13.1.1: If-Match precondition evaluation
+    // RFC 9110 section 13.1.4: If-Unmodified-Since precondition evaluation
+    if (options.preconditionFailed(etag, mtime)) {
+        return void response.writeHead(StatusCode.PreconditionFailed).end();
+    }
+    // RFC 9110 section 13.1.2: If-None-Match precondition evaluation
+    // RFC 9110 section 13.1.3: If-Modified-Since precondition evaluation
+    else if (options.notModified(etag, mtime)) {
+        return void response.writeHead(StatusCode.NotModified).end();
+    }
+    const range = parseRange(request);
+    if (range === null) {
+        return void response.writeHead(StatusCode.BadRequest).end();
+    }
+    const abortController = new AbortController();
+    request.on('close', () => abortController.abort());
+    const signal = abortController.signal;
+    store.request(filename, {
+        method: 'GET',
+        range,
+        signal,
+        // pipeline automatically destroys the streams if they were not gracefully closed
+        callback: async (result) => {
+            if (response.destroyed)
+                return void response.destroy();
+            switch (result.type) {
+                case 'InternalError':
+                    // object store encountered network error, retry by client can help
+                    return void response.writeHead(StatusCode.InternalServerError).end();
+                case 'NotFound':
+                    // RFC 9110 section 15.4.5: Not found
+                    return void response.writeHead(StatusCode.NotFound).end();
+                case 'RangeNotSatisfiable':
+                    // RFC 9110 section 15.5.17: Range not satisfiable
+                    response.setHeader(HeaderName.ContentRange, `bytes */${result.size}`);
+                    return void response.writeHead(StatusCode.RangeNotSatisfiable).end();
+            }
+            if (isGet(method) && !result.data) {
+                // object store implementation is incorrect, retry by client cannot help
+                return void response.writeHead(StatusCode.GatewayTimeout).end();
+            }
+            if (range) {
+                // RFC 9110 section 14.4: Partial content response
+                response.setHeader(HeaderName.ContentLength, result.range.end - result.range.start + 1);
+                response.setHeader(HeaderName.ContentRange, `bytes ${result.range.start}-${result.range.end}/${result.size}`);
+                response.writeHead(StatusCode.PartialContent);
+            }
+            else {
+                // RFC 9110 section 15.3.1: OK response
+                response.setHeader(HeaderName.ContentLength, result.size);
+                response.writeHead(StatusCode.Ok);
+            }
+            // RFC 9110 section 9.3.2: HEAD method must not return message body
+            if (isHead(method)) {
+                return void response.end();
+            }
+            return await pipeline(result.data, response, { signal }).catch(() => {
+                // Pipeline errors are expected when request is aborted or connection is lost
+                // Response head was already written, so we can't change status code
+                // Just mute the error - pipeline destroys the response stream
+            });
+        }
+    });
+}
+/**
+ * Create a request handler for serving files from an object store
+ * compatible with HTTP/1.1 as defined in RFC 9110 and RFC 9111:
+ * - <https://datatracker.ietf.org/doc/html/rfc9110>
+ * - <https://datatracker.ietf.org/doc/html/rfc9111>
+ *
+ * Accepts only paths of the form `/<filename>.parquet`, returns 404 otherwise
+ * Assumes that files are immutable (and sets cache headers accordingly)
+ */
+function createRequestHandler(options) {
+    const { store } = options;
+    return (request, response) => void handleRequest(request, response, store);
+}
+/** Request authorization middleware */
+function authorizeRequest(request, response, handler, authHeader) {
+    // RFC 9110 section 6.6.1: Date header should be present in all responses
+    response.sendDate = true;
+    // RFC 9110 section 8.6: Content-Length 0 as default for error responses
+    response.strictContentLength = true;
+    response.setHeader(HeaderName.ContentLength, 0);
+    // Note: setting Content-Length disables Node.js default Transfer-Encoding: chunked
+    const actualHeader = request.headers['authorization'];
+    // Early length check to avoid unnecessary processing
+    if (!actualHeader || actualHeader.length !== authHeader.length) {
+        // RFC 9110 section 11.6.1: WWW-Authenticate header field
+        response.setHeader(HeaderName.WWWAuthenticate, HeaderValue.WWWAuthenticate);
+        return void response.writeHead(StatusCode.Unauthorized).end();
+    }
+    // Use timing-safe comparison to prevent timing attacks
+    // <https://developers.cloudflare.com/workers/examples/protect-against-timing-attacks/>
+    const encoder = new TextEncoder();
+    const receivedBuffer = encoder.encode(actualHeader);
+    const expectedBuffer = encoder.encode(authHeader);
+    if (receivedBuffer.byteLength !== expectedBuffer.byteLength ||
+        !timingSafeEqual(receivedBuffer, expectedBuffer)) {
+        response.setHeader(HeaderName.WWWAuthenticate, HeaderValue.WWWAuthenticate);
+        return void response.writeHead(StatusCode.Unauthorized).end();
+    }
+    return handler(request, response);
+}
+/** Apply Bearer token authorization to @param handler */
+function authorizeRequestHandler(handler, authToken) {
+    const authHeader = `Bearer ${authToken}`;
+    return (request, response) => authorizeRequest(request, response, handler, authHeader);
+}
+
+export { authorizeRequestHandler, createRequestHandler };
+//# sourceMappingURL=handler.js.map