@milaboratories/pframes-rs-serv 1.1.3 → 1.1.4

package/src/serve.ts

@@ -2,52 +2,42 @@ import {
   createServer as createHttpServer,
   type RequestListener,
   type Server as HttpServer,
-  type ServerOptions
-} from 'node:http';
-import {
-  createServer as createHttpsServer,
-  type Server as HttpsServer
-} from 'node:https';
-import type { AddressInfo } from 'node:net';
-import { Deferred } from '@milaboratories/helpers';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import {
-  base64Encode,
-  Base64Encoded,
-  ensureError
-} from '@milaboratories/pl-model-common';
-import { generate, type GenerateResult } from 'selfsigned';
-import { randomUUID } from 'node:crypto';
-import { authorizeRequestHandler } from './handler';
+  type ServerOptions,
+} from "node:http";
+import { createServer as createHttpsServer, type Server as HttpsServer } from "node:https";
+import type { AddressInfo } from "node:net";
+import { Deferred } from "@milaboratories/helpers";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import { base64Encode, Base64Encoded, ensureError } from "@milaboratories/pl-model-common";
+import { generate, type GenerateResult } from "selfsigned";
+import { randomUUID } from "node:crypto";
+import { authorizeRequestHandler } from "./handler";
 
 /** Generate a self-signed certificate for localhost */
 async function generateCertificate(): Promise<GenerateResult> {
-  return await generate([{ name: 'commonName', value: 'localhost' }], {
+  return await generate([{ name: "commonName", value: "localhost" }], {
     keySize: 2048,
-    algorithm: 'sha256',
+    algorithm: "sha256",
     extensions: [
       {
-        name: 'subjectAltName',
+        name: "subjectAltName",
         altNames: [
-          { type: 2, value: 'localhost' }, // DNS
-          { type: 7, ip: '127.0.0.1' }, // IPv4
-          { type: 7, ip: '::1' } // IPv6
-        ]
-      }
-    ]
+          { type: 2, value: "localhost" }, // DNS
+          { type: 7, ip: "127.0.0.1" }, // IPv4
+          { type: 7, ip: "::1" }, // IPv6
+        ],
+      },
+    ],
   });
 }
 
 /** Create an object store URL from the server address info. */
-function createObjectStoreUrl(
-  info: AddressInfo,
-  noHttps?: true
-): PFrameInternal.ObjectStoreUrl {
-  const protocol = noHttps ? 'http' : 'https';
+function createObjectStoreUrl(info: AddressInfo, noHttps?: true): PFrameInternal.ObjectStoreUrl {
+  const protocol = noHttps ? "http" : "https";
   switch (info.family) {
-    case 'IPv4':
+    case "IPv4":
       return `${protocol}://${info.address}:${info.port}/` as PFrameInternal.ObjectStoreUrl;
-    case 'IPv6':
+    case "IPv6":
       return `${protocol}://[${info.address}]:${info.port}/` as PFrameInternal.ObjectStoreUrl;
     default:
       return `${protocol}://localhost:${info.port}/` as PFrameInternal.ObjectStoreUrl;
@@ -62,7 +52,7 @@ export async function serve({
   handler,
   port = 0,
   noHttps,
-  noAuth
+  noAuth,
 }: PFrameInternal.HttpServerOptions): Promise<PFrameInternal.HttpServer> {
   const started = new Deferred<PFrameInternal.HttpServer>();
   try {
@@ -78,7 +68,7 @@ export async function serve({
     // Create HTTP server
     let encodedCaCert: Base64Encoded<PFrameInternal.PemCertificate> | undefined;
     const defaultOptions: ServerOptions = {
-      keepAlive: true
+      keepAlive: true,
     };
     let server: HttpServer | HttpsServer;
 
@@ -87,19 +77,13 @@ export async function serve({
     } else {
       const { cert, private: key, public: ca } = await generateCertificate();
       encodedCaCert = base64Encode(cert as PFrameInternal.PemCertificate);
-      server = createHttpsServer(
-        { ...defaultOptions, cert, key, ca },
-        effectiveHandler
-      );
+      server = createHttpsServer({ ...defaultOptions, cert, key, ca }, effectiveHandler);
     }
 
     server
-      .on('listening', () => {
+      .on("listening", () => {
         // Cast is safe by specification <https://nodejs.org/api/net.html#serveraddress>
-        const url = createObjectStoreUrl(
-          server.address() as AddressInfo,
-          noHttps
-        );
+        const url = createObjectStoreUrl(server.address() as AddressInfo, noHttps);
         stopped = new Deferred<void>();
 
         started.resolve({
@@ -112,17 +96,17 @@ export async function serve({
           stop(): Promise<void> {
             server.close();
             return stopped!.promise;
-          }
+          },
         });
       })
-      .on('error', (err) => {
+      .on("error", (err) => {
         started.reject(err);
         stopped?.reject(err);
       })
-      .on('close', () => stopped?.resolve())
+      .on("close", () => stopped?.resolve())
       .listen({
-        host: 'localhost',
-        port
+        host: "localhost",
+        port,
       });
   } catch (error: unknown) {
     started.reject(ensureError(error));

package/src/utils/etag.ts

@@ -1,5 +1,5 @@
-import type { Branded } from '@milaboratories/pl-model-common';
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
+import type { Branded } from "@milaboratories/pl-model-common";
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
 
 /**
  * See <https://datatracker.ietf.org/doc/html/rfc9110#section-8.8.3>
@@ -11,10 +11,10 @@ import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
  * ETag: W/"xyzzy"
  * ```
  */
-export type Etag = Branded<string, 'Etag'>;
+export type Etag = Branded<string, "Etag">;
 
 export function createETag(filename: PFrameInternal.ParquetFileName): Etag {
   // For immutable files, use URL-safe base64 encoded filename as ETag
-  const filenameETag = Buffer.from(filename, 'utf8').toString('base64url');
+  const filenameETag = Buffer.from(filename, "utf8").toString("base64url");
   return `"${filenameETag}"` as Etag;
 }

package/src/utils/filename.ts

@@ -1,10 +1,10 @@
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import type { IncomingMessage } from 'node:http';
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import type { IncomingMessage } from "node:http";
 
 const PARQUET_FILENAME_REGEX = /^\/([\w\-.]+.parquet)$/;
 
 export function getFilenameFromUrl(
-  request: IncomingMessage
+  request: IncomingMessage,
 ): PFrameInternal.ParquetFileName | null {
   const url = request.url;
   if (url === undefined) return null;

package/src/utils/headers.ts

@@ -1,31 +1,31 @@
 /** HTTP header names used in the parquet server handler */
 export const HeaderName = {
-  Accept: 'accept',
-  AcceptRanges: 'accept-ranges',
-  Allow: 'allow',
-  Authorization: 'authorization',
-  CacheControl: 'cache-control',
-  Connection: 'connection',
-  ContentLength: 'content-length',
-  ContentRange: 'content-range',
-  ContentType: 'content-type',
-  Date: 'date',
-  ETag: 'etag',
-  IfMatch: 'if-match',
-  IfModifiedSince: 'if-modified-since',
-  IfNoneMatch: 'if-none-match',
-  IfUnmodifiedSince: 'if-unmodified-since',
-  LastModified: 'last-modified',
-  Range: 'range',
-  WWWAuthenticate: 'www-authenticate'
+  Accept: "accept",
+  AcceptRanges: "accept-ranges",
+  Allow: "allow",
+  Authorization: "authorization",
+  CacheControl: "cache-control",
+  Connection: "connection",
+  ContentLength: "content-length",
+  ContentRange: "content-range",
+  ContentType: "content-type",
+  Date: "date",
+  ETag: "etag",
+  IfMatch: "if-match",
+  IfModifiedSince: "if-modified-since",
+  IfNoneMatch: "if-none-match",
+  IfUnmodifiedSince: "if-unmodified-since",
+  LastModified: "last-modified",
+  Range: "range",
+  WWWAuthenticate: "www-authenticate",
 } as const;
 
 /** HTTP header values used in the parquet server handler */
 export const HeaderValue = {
-  AcceptRanges: 'bytes',
-  Allow: 'GET, HEAD',
-  CacheControl: 'public, immutable, max-age=31536000',
-  Connection: 'close',
-  ContentType: 'application/octet-stream',
-  WWWAuthenticate: 'Bearer realm="parquet-server"'
+  AcceptRanges: "bytes",
+  Allow: "GET, HEAD",
+  CacheControl: "public, immutable, max-age=31536000",
+  Connection: "close",
+  ContentType: "application/octet-stream",
+  WWWAuthenticate: 'Bearer realm="parquet-server"',
 } as const;

package/src/utils/index.ts

@@ -1,7 +1,7 @@
-export * from './filename';
-export * from './etag';
-export * from './headers';
-export * from './options';
-export * from './range';
-export * from './method';
-export * from './status';
+export * from "./filename";
+export * from "./etag";
+export * from "./headers";
+export * from "./options";
+export * from "./range";
+export * from "./method";
+export * from "./status";

package/src/utils/method.ts

@@ -1,20 +1,20 @@
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import type { IncomingHttpHeaders } from 'node:http';
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import type { IncomingHttpHeaders } from "node:http";
 
 export function isGetOrHead(
-  method: IncomingHttpHeaders['method']
+  method: IncomingHttpHeaders["method"],
 ): method is PFrameInternal.HttpMethod {
-  return method === 'GET' || method === 'HEAD';
+  return method === "GET" || method === "HEAD";
 }
 
 export function isGet(
-  method: PFrameInternal.HttpMethod
-): method is Extract<PFrameInternal.HttpMethod, 'GET'> {
-  return method === 'GET';
+  method: PFrameInternal.HttpMethod,
+): method is Extract<PFrameInternal.HttpMethod, "GET"> {
+  return method === "GET";
 }
 
 export function isHead(
-  method: PFrameInternal.HttpMethod
-): method is Extract<PFrameInternal.HttpMethod, 'HEAD'> {
-  return method === 'HEAD';
+  method: PFrameInternal.HttpMethod,
+): method is Extract<PFrameInternal.HttpMethod, "HEAD"> {
+  return method === "HEAD";
 }

package/src/utils/options.ts

@@ -1,13 +1,13 @@
-import type { IncomingMessage } from 'node:http';
-import type { Etag } from './etag';
+import type { IncomingMessage } from "node:http";
+import type { Etag } from "./etag";
 
 type EtagMatchType =
   | {
-      type: 'match';
+      type: "match";
       value: Etag[];
     }
   | {
-      type: 'wildcard';
+      type: "wildcard";
     };
 
 class EtagMatch {
@@ -15,21 +15,21 @@ class EtagMatch {
 
   static parse(etagMatch: string | undefined): EtagMatch | null {
     if (etagMatch === undefined) return null;
-    if (etagMatch === '*') {
-      return new EtagMatch({ type: 'wildcard' });
+    if (etagMatch === "*") {
+      return new EtagMatch({ type: "wildcard" });
     } else {
       return new EtagMatch({
-        type: 'match',
-        value: etagMatch.split(',').map((etag) => etag.trim() as Etag)
+        type: "match",
+        value: etagMatch.split(",").map((etag) => etag.trim() as Etag),
       });
     }
   }
 
   matches(etag: Etag): boolean {
     switch (this.etagMatch.type) {
-      case 'match':
+      case "match":
         return this.etagMatch.value.includes(etag);
-      case 'wildcard':
+      case "wildcard":
         return true;
     }
   }
@@ -100,14 +100,10 @@ export class Options {
   private ifUnmodifiedSince: DateMatch | null;
 
   constructor(request: IncomingMessage) {
-    this.ifMatch = EtagMatch.parse(request.headers['if-match']);
-    this.ifNoneMatch = EtagMatch.parse(request.headers['if-none-match']);
-    this.ifModifiedSince = DateMatch.parse(
-      request.headers['if-modified-since']
-    );
-    this.ifUnmodifiedSince = DateMatch.parse(
-      request.headers['if-unmodified-since']
-    );
+    this.ifMatch = EtagMatch.parse(request.headers["if-match"]);
+    this.ifNoneMatch = EtagMatch.parse(request.headers["if-none-match"]);
+    this.ifModifiedSince = DateMatch.parse(request.headers["if-modified-since"]);
+    this.ifUnmodifiedSince = DateMatch.parse(request.headers["if-unmodified-since"]);
   }
 
   /**

package/src/utils/range.ts

@@ -1,10 +1,8 @@
-import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
-import type { IncomingMessage } from 'node:http';
+import type { PFrameInternal } from "@milaboratories/pl-model-middle-layer";
+import type { IncomingMessage } from "node:http";
 
-export function parseRange(
-  request: IncomingMessage
-): PFrameInternal.HttpRange | null | undefined {
-  const range = request.headers['range'];
+export function parseRange(request: IncomingMessage): PFrameInternal.HttpRange | null | undefined {
+  const range = request.headers["range"];
   if (range === undefined) return undefined;
 
   const match = range.match(/^bytes=(\d*)-(\d*)$/);
@@ -22,17 +20,17 @@ export function parseRange(
 
   // Both start and end are specified - bounded range
   if (start !== null && end !== null) {
-    return { type: 'bounded', start, end };
+    return { type: "bounded", start, end };
   }
 
   // Only start is specified - offset range (e.g., bytes=500-)
   if (start !== null && end === null) {
-    return { type: 'offset', offset: start };
+    return { type: "offset", offset: start };
   }
 
   // Only end is specified - suffix range (e.g., bytes=-500)
   if (start === null && end !== null) {
-    return { type: 'suffix', suffix: end };
+    return { type: "suffix", suffix: end };
   }
 
   // Neither start nor end specified (bytes=-) - invalid

package/src/utils/status.ts

@@ -12,5 +12,5 @@ export const StatusCode = {
   PreconditionFailed: 412, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/412>
   RangeNotSatisfiable: 416, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/416>
   InternalServerError: 500, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/500>
-  GatewayTimeout: 504 // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/504>
+  GatewayTimeout: 504, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/504>
 } as const;