@milaboratories/pframes-rs-serv 1.1.3 → 1.1.5

package/package.json

@@ -1,5 +1,6 @@
 {
   "name": "@milaboratories/pframes-rs-serv",
+  "version": "1.1.5",
   "description": "PFrames - Node.js HTTP(S) Parquet Server",
   "keywords": [
     "http",
@@ -8,10 +9,23 @@
     "proxy",
     "server"
   ],
-  "version": "1.1.3",
+  "homepage": "https://github.com/milaboratory/pframes-rs#readme",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/milaboratory/pframes-rs.git"
+  },
+  "bin": {
+    "parquet-server": "./bin/parquet-server.mjs"
+  },
+  "files": [
+    "src/**/*",
+    "bin/**/*",
+    "dist/**/*"
+  ],
   "type": "module",
-  "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -19,24 +33,19 @@
       "require": "./dist/index.cjs"
     }
   },
-  "bin": {
-    "parquet-server": "./bin/parquet-server.mjs"
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
   },
-  "files": [
-    "src/**/*",
-    "bin/**/*",
-    "dist/**/*"
-  ],
   "dependencies": {
     "@milaboratories/helpers": "1.13.1",
-    "@milaboratories/pl-model-common": "1.24.6",
-    "@milaboratories/pl-model-middle-layer": "1.11.8",
+    "@milaboratories/pl-model-common": "1.24.7",
+    "@milaboratories/pl-model-middle-layer": "1.11.9",
     "commander": "^14.0.2",
     "selfsigned": "^5.4.0"
   },
   "devDependencies": {
     "@datadog/pprof": "^5.13.1",
-    "@milaboratories/ts-builder": "1.2.5",
+    "@milaboratories/ts-builder": "1.2.9",
     "@milaboratories/ts-configs": "1.2.0",
     "@types/autocannon": "^7.12.7",
     "@types/node": "~22.19.5",
@@ -46,26 +55,16 @@
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
     "undici": "^7.18.2",
-    "vite": "^7.3.1",
     "vitest": "^4.0.17"
   },
-  "license": "UNLICENSED",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org"
-  },
-  "homepage": "https://github.com/milaboratory/pframes-rs#readme",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/milaboratory/pframes-rs.git"
-  },
   "scripts": {
     "bump-version": "cargo run -p pframes_rs_meta --bin npm_version -r --locked",
-    "type-check": "pnpm exec tsc --noEmit",
-    "ts-build": "pnpm exec ts-builder build --target node",
+    "fix": "ts-builder format",
+    "check": "ts-builder linter --check --target node && ts-builder formatter --check",
+    "build": "ts-builder build --target node",
     "postts-build": "pnpm exec rimraf package.tgz && pnpm pack --out package.tgz",
-    "build": "pnpm run ts-build",
     "pretest": "pnpm run build",
-    "test": "pnpm run type-check && pnpm exec vitest run --coverage",
+    "test": "ts-builder type-check --target node && pnpm exec vitest run --coverage",
     "ci-test": "pnpm run test"
   }
 }

package/src/export.ts

@@ -1,23 +1,21 @@
-import type { RequestListener } from 'node:http';
-import { FileSystemStore } from './fs-store';
-import { createRequestHandler } from './handler';
-import { serve } from './serve';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import type { RequestListener } from "node:http";
+import { FileSystemStore } from "./fs-store";
+import { createRequestHandler } from "./handler";
+import { serve } from "./serve";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 
 export const HttpHelpers: PFrameInternal.HttpHelpers = {
   createFsStore: async (
-    options: PFrameInternal.FsStoreOptions
+    options: PFrameInternal.FsStoreOptions,
   ): Promise<PFrameInternal.ObjectStore> => {
     return await FileSystemStore.init(options);
   },
-  createRequestHandler: (
-    options: PFrameInternal.RequestHandlerOptions
-  ): RequestListener => {
+  createRequestHandler: (options: PFrameInternal.RequestHandlerOptions): RequestListener => {
     return createRequestHandler(options);
   },
   createHttpServer: async (
-    options: PFrameInternal.HttpServerOptions
+    options: PFrameInternal.HttpServerOptions,
   ): Promise<PFrameInternal.HttpServer> => {
     return await serve(options);
-  }
+  },
 };

package/src/fs-store.ts

@@ -1,8 +1,8 @@
-import type { Readable } from 'node:stream';
-import { stat, open, type FileHandle } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import { ensureError, isAbortError } from '@milaboratories/pl-model-common';
+import type { Readable } from "node:stream";
+import { stat, open, type FileHandle } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { ensureError, isAbortError } from "@milaboratories/pl-model-common";
 
 /** Object store for serving files from a local directory */
 export class FileSystemStore extends PFrameInternal.BaseObjectStore {
@@ -14,25 +14,19 @@ export class FileSystemStore extends PFrameInternal.BaseObjectStore {
     this.rootDir = options.rootDir;
   }
 
-  static async init(
-    options: PFrameInternal.FsStoreOptions
-  ): Promise<FileSystemStore> {
+  static async init(options: PFrameInternal.FsStoreOptions): Promise<FileSystemStore> {
     const resolvedRootDir = resolve(options.rootDir);
 
     const rootStats = await stat(resolvedRootDir).catch(() => {
-      throw new Error(
-        `File system store root directory does not exist: ${resolvedRootDir}`
-      );
+      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}`
-      );
+      throw new Error(`File system store root path is not a directory: ${resolvedRootDir}`);
     }
 
     return new FileSystemStore({
       ...options,
-      rootDir: resolvedRootDir
+      rootDir: resolvedRootDir,
     });
   }
 
@@ -43,18 +37,16 @@ export class FileSystemStore extends PFrameInternal.BaseObjectStore {
       range?: PFrameInternal.HttpRange;
       signal: AbortSignal;
       callback: (response: PFrameInternal.ObjectStoreResponse) => Promise<void>;
-    }
+    },
   ): Promise<void> {
     let file: FileHandle | undefined;
     const respond = async (response: PFrameInternal.ObjectStoreResponse) => {
       try {
-        await params
-          .callback(response)
-          .finally(async () => await file?.close());
+        await params.callback(response).finally(async () => await file?.close());
       } catch (error: unknown) {
         this.logger(
-          'warn',
-          `File system store received unexpected rejection from callback: ${ensureError(error)}`
+          "warn",
+          `File system store received unexpected rejection from callback: ${ensureError(error)}`,
         );
       }
     };
@@ -62,13 +54,13 @@ export class FileSystemStore extends PFrameInternal.BaseObjectStore {
     try {
       try {
         const path = join(this.rootDir, filename);
-        file = await open(path, 'r');
+        file = await open(path, "r");
       } catch (error: unknown) {
         this.logger(
-          'error',
-          `File system store failed to open file ${filename}: ${ensureError(error)}`
+          "error",
+          `File system store failed to open file ${filename}: ${ensureError(error)}`,
         );
-        return await respond({ type: 'NotFound' });
+        return await respond({ type: "NotFound" });
       }
       params.signal.throwIfAborted();
 
@@ -77,20 +69,20 @@ export class FileSystemStore extends PFrameInternal.BaseObjectStore {
         ({ size } = await file.stat());
       } catch (error: unknown) {
         this.logger(
-          'error',
-          `File system store failed to get size of file ${filename}: ${ensureError(error)}`
+          "error",
+          `File system store failed to get size of file ${filename}: ${ensureError(error)}`,
         );
-        return await respond({ type: 'InternalError' });
+        return await respond({ type: "InternalError" });
       }
       params.signal.throwIfAborted();
 
       const range = this.translate(size, params.range);
       if (!range) {
-        return await respond({ type: 'RangeNotSatisfiable', size });
+        return await respond({ type: "RangeNotSatisfiable", size });
       }
 
-      if (params.method === 'HEAD') {
-        return await respond({ type: 'Ok', size, range });
+      if (params.method === "HEAD") {
+        return await respond({ type: "Ok", size, range });
       }
 
       let data: Readable;
@@ -98,29 +90,26 @@ export class FileSystemStore extends PFrameInternal.BaseObjectStore {
         data = file.createReadStream({
           start: range.start,
           end: range.end,
-          autoClose: false
+          autoClose: false,
         });
         this.logger(
-          'info',
-          `File system store created read stream for ${filename}[${range.start}..=${range.end}]`
+          "info",
+          `File system store created read stream for ${filename}[${range.start}..=${range.end}]`,
         );
       } catch (error: unknown) {
         this.logger(
-          'error',
-          `File system store failed to create read stream for ${filename}[${range.start}..=${range.end}]: ${ensureError(error)}`
+          "error",
+          `File system store failed to create read stream for ${filename}[${range.start}..=${range.end}]: ${ensureError(error)}`,
         );
-        return await respond({ type: 'InternalError' });
+        return await respond({ type: "InternalError" });
       }
 
-      return await respond({ type: 'Ok', size, range, data });
+      return await respond({ type: "Ok", size, range, data });
     } catch (error: unknown) {
       if (!isAbortError(error)) {
-        this.logger(
-          'warn',
-          `File system store unhandled error: ${ensureError(error)}`
-        );
+        this.logger("warn", `File system store unhandled error: ${ensureError(error)}`);
       }
-      return await respond({ type: 'InternalError' });
+      return await respond({ type: "InternalError" });
     }
   }
 }

package/src/handler.ts

@@ -1,11 +1,7 @@
-import type {
-  IncomingMessage,
-  RequestListener,
-  ServerResponse
-} from 'node:http';
-import { pipeline } from 'node:stream/promises';
-import { timingSafeEqual } from 'node:crypto';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import type { IncomingMessage, RequestListener, ServerResponse } from "node:http";
+import { pipeline } from "node:stream/promises";
+import { timingSafeEqual } from "node:crypto";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 import {
   createETag,
   getFilenameFromUrl,
@@ -16,15 +12,15 @@ import {
   Options,
   StatusCode,
   HeaderName,
-  HeaderValue
-} from './utils';
-import { isAbortError } from '@milaboratories/pl-model-common';
+  HeaderValue,
+} from "./utils";
+import { isAbortError } from "@milaboratories/pl-model-common";
 
 /** Main request handler for parquet files */
 function handleRequest(
   request: IncomingMessage,
   response: ServerResponse,
-  store: PFrameInternal.ObjectStore
+  store: PFrameInternal.ObjectStore,
 ): void {
   // RFC 9110 section 6.6.1: Date header should be present in all responses
   response.sendDate = true;
@@ -79,7 +75,7 @@ function handleRequest(
   }
 
   const abortController = new AbortController();
-  request.on('close', () => abortController.abort());
+  request.on("close", () => abortController.abort());
   const signal = abortController.signal;
 
   store.request(filename, {
@@ -101,17 +97,17 @@ function handleRequest(
       }
 
       switch (result.type) {
-        case 'InternalError':
+        case "InternalError":
           // object store encountered network error, retry by client can help
           return void response.writeHead(StatusCode.InternalServerError).end();
-        case 'NotFound':
+        case "NotFound":
           // RFC 9110 section 15.4.5: Not found
           return void response.writeHead(StatusCode.NotFound).end();
-        case 'RangeNotSatisfiable':
+        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();
-        case 'Ok':
+        case "Ok":
           break;
       }
 
@@ -122,13 +118,10 @@ function handleRequest(
 
       if (range) {
         // RFC 9110 section 14.4: Partial content response
-        response.setHeader(
-          HeaderName.ContentLength,
-          result.range.end - result.range.start + 1
-        );
+        response.setHeader(HeaderName.ContentLength, result.range.end - result.range.start + 1);
         response.setHeader(
           HeaderName.ContentRange,
-          `bytes ${result.range.start}-${result.range.end}/${result.size}`
+          `bytes ${result.range.start}-${result.range.end}/${result.size}`,
         );
         response.writeHead(StatusCode.PartialContent);
       } else {
@@ -147,7 +140,7 @@ function handleRequest(
       } catch (error: unknown) {
         if (!isAbortError(error)) throw error;
       }
-    }
+    },
   });
 }
 
@@ -161,7 +154,7 @@ function handleRequest(
  * Assumes that files are immutable (and sets cache headers accordingly)
  */
 export function createRequestHandler(
-  options: PFrameInternal.RequestHandlerOptions
+  options: PFrameInternal.RequestHandlerOptions,
 ): RequestListener {
   const { store } = options;
   return (request, response) => handleRequest(request, response, store);
@@ -172,7 +165,7 @@ function authorizeRequest(
   request: IncomingMessage,
   response: ServerResponse,
   handler: RequestListener,
-  authHeader: string
+  authHeader: string,
 ): void {
   // RFC 9110 section 6.6.1: Date header should be present in all responses
   response.sendDate = true;
@@ -210,9 +203,8 @@ function authorizeRequest(
 /** Apply Bearer token authorization to @param handler */
 export function authorizeRequestHandler(
   handler: RequestListener,
-  authToken: PFrameInternal.HttpAuthorizationToken
+  authToken: PFrameInternal.HttpAuthorizationToken,
 ): RequestListener {
   const authHeader = `Bearer ${authToken}`;
-  return (request, response) =>
-    authorizeRequest(request, response, handler, authHeader);
+  return (request, response) => authorizeRequest(request, response, handler, authHeader);
 }

package/src/index.ts

@@ -1,5 +1,5 @@
-export * from './handler';
-export * from './fs-store';
-export * from './serve';
-export * from './export';
-export * from './parquet-server';
+export * from "./handler";
+export * from "./fs-store";
+export * from "./serve";
+export * from "./export";
+export * from "./parquet-server";

package/src/parquet-server.ts

@@ -1,20 +1,16 @@
-import { type ChildProcess, spawn } from 'node:child_process';
-import { createInterface, type Interface } from 'node:readline/promises';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { Command, InvalidArgumentError } from 'commander';
-import { HttpHelpers } from './export';
-import {
-  parseJson,
-  stringifyJson,
-  type StringifiedJson
-} from '@milaboratories/pl-model-common';
-import { type PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import { type ChildProcess, spawn } from "node:child_process";
+import { createInterface, type Interface } from "node:readline/promises";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command, InvalidArgumentError } from "commander";
+import { HttpHelpers } from "./export";
+import { parseJson, stringifyJson, type StringifiedJson } from "@milaboratories/pl-model-common";
+import { type PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 
 const Options = {
-  NoHttps: '--no-https',
-  NoAuth: '--no-auth',
-  Port: '--port'
+  NoHttps: "--no-https",
+  NoAuth: "--no-auth",
+  Port: "--port",
 } as const;
 
 type Info = StringifiedJson<PFrameInternal.HttpServerInfo>;
@@ -27,22 +23,22 @@ export async function runParquetServer(): Promise<void> {
   const program = new Command();
 
   program
-    .name('parquet-server')
-    .description('Serve parquet files from a directory over HTTP(S)')
-    .argument('<root-directory>', 'Root directory containing parquet files')
-    .option(Options.NoHttps, 'Downgrade HTTPS to HTTP')
-    .option(Options.NoAuth, 'Disable authorization')
+    .name("parquet-server")
+    .description("Serve parquet files from a directory over HTTP(S)")
+    .argument("<root-directory>", "Root directory containing parquet files")
+    .option(Options.NoHttps, "Downgrade HTTPS to HTTP")
+    .option(Options.NoAuth, "Disable authorization")
     .option(
       `${Options.Port} <number>`,
-      'Port to listen on',
+      "Port to listen on",
       (value) => {
         const port = parseInt(value, 10);
         if (isNaN(port) || port < 0 || port > 65535) {
-          throw new InvalidArgumentError('valid port numbers are 0-65535');
+          throw new InvalidArgumentError("valid port numbers are 0-65535");
         }
         return port;
       },
-      0
+      0,
     )
     .action(
       async (
@@ -51,12 +47,12 @@ export async function runParquetServer(): Promise<void> {
           https: boolean;
           auth: boolean;
           port: number;
-        }
+        },
       ) => {
         const abortController = new AbortController();
         process
-          .on('SIGINT', () => abortController.abort())
-          .on('SIGTERM', () => abortController.abort());
+          .on("SIGINT", () => abortController.abort())
+          .on("SIGTERM", () => abortController.abort());
         abortController.signal.throwIfAborted();
 
         const store = await HttpHelpers.createFsStore({
@@ -64,7 +60,7 @@ export async function runParquetServer(): Promise<void> {
           logger: (level, message) => {
             const timestamp = new Date(Date.now()).toISOString();
             console.log(`[${timestamp}] [${level}] ${message}`);
-          }
+          },
         });
         abortController.signal.throwIfAborted();
         const handler = HttpHelpers.createRequestHandler({ store });
@@ -73,7 +69,7 @@ export async function runParquetServer(): Promise<void> {
           handler,
           ...(!options.https && { noHttps: true }),
           ...(!options.auth && { noAuth: true }),
-          port: options.port
+          port: options.port,
         });
         abortController.signal.onabort = () => server.stop();
         abortController.signal.throwIfAborted();
@@ -82,7 +78,7 @@ export async function runParquetServer(): Promise<void> {
         console.log(serverInfo);
 
         await server.stopped;
-      }
+      },
     );
 
   await program.parseAsync();
@@ -102,7 +98,7 @@ export class ParquetServer implements Disposable {
   private constructor(
     process: ChildProcess,
     info: PFrameInternal.HttpServerInfo,
-    lineReader: Interface
+    lineReader: Interface,
   ) {
     this.#process = process;
     this.#info = info;
@@ -119,23 +115,23 @@ export class ParquetServer implements Disposable {
       noHttps?: true;
       noAuth?: true;
       port?: number;
-    }
+    },
   ): Promise<ParquetServer> {
     const nodeDirname = dirname(fileURLToPath(import.meta.url));
-    const binPath = join(nodeDirname, '..', 'bin', 'parquet-server.mjs');
+    const binPath = join(nodeDirname, "..", "bin", "parquet-server.mjs");
 
     const serverProcess = spawn(
-      'node',
+      "node",
       [
         binPath,
         rootDir,
         ...(options?.noHttps ? [Options.NoHttps] : []),
         ...(options?.noAuth ? [Options.NoAuth] : []),
-        ...(options?.port ? [Options.Port, options.port.toString()] : [])
+        ...(options?.port ? [Options.Port, options.port.toString()] : []),
       ],
       {
-        stdio: ['ignore', 'pipe', 'ignore']
-      }
+        stdio: ["ignore", "pipe", "ignore"],
+      },
     );
 
     const lineReader = createInterface({ input: serverProcess.stdout! });
@@ -143,7 +139,7 @@ export class ParquetServer implements Disposable {
     const firstLine = await lineReader[Symbol.asyncIterator]().next();
     const serverInfo = parseJson(firstLine.value as Info);
 
-    lineReader.on('line', console.log);
+    lineReader.on("line", console.log);
 
     return new ParquetServer(serverProcess, serverInfo, lineReader);
   }