@milaboratories/pframes-rs-serv 1.0.68 → 1.0.70

package/src/serve.ts

@@ -14,8 +14,7 @@ import type { PFrameInternal } from '@milaboratories/pl-model-middle-layer';
 import {
   base64Encode,
   Base64Encoded,
-  ensureError,
-  PFrameError
+  ensureError
 } from '@milaboratories/pl-model-common';
 import { generate, type GenerateResult } from 'selfsigned';
 import { randomUUID } from 'node:crypto';
@@ -54,18 +53,16 @@ async function generateCertificate(): Promise<GenerateResult> {
 /** Create an object store URL from the server address info. */
 function createObjectStoreUrl(
   info: AddressInfo,
-  http?: true
+  noHttps?: true
 ): PFrameInternal.ObjectStoreUrl {
-  const protocol = http ? 'http' : 'https';
+  const protocol = noHttps ? 'http' : 'https';
   switch (info.family) {
     case 'IPv4':
       return `${protocol}://${info.address}:${info.port}/` as PFrameInternal.ObjectStoreUrl;
     case 'IPv6':
       return `${protocol}://[${info.address}]:${info.port}/` as PFrameInternal.ObjectStoreUrl;
     default:
-      throw new PFrameError(
-        `PFrame helper HTTP(S) server bound to 'localhost' has unknown address family: ${info.family}`
-      );
+      return `${protocol}://localhost:${info.port}/` as PFrameInternal.ObjectStoreUrl;
   }
 }
 
@@ -76,7 +73,7 @@ function createObjectStoreUrl(
 export async function serve({
   handler,
   port = 0,
-  http,
+  noHttps,
   noAuth
 }: PFrameInternal.HttpServerOptions): Promise<PFrameInternal.HttpServer> {
   const started = new Deferred<PFrameInternal.HttpServer>();
@@ -91,52 +88,41 @@ export async function serve({
     }
 
     // Create HTTP server
-    let certificateBase64:
-      | Base64Encoded<PFrameInternal.PemCertificate>
-      | undefined;
+    let encodedCaCert: Base64Encoded<PFrameInternal.PemCertificate> | undefined;
     const defaultOptions: ServerOptions = {
       keepAlive: true
     };
     let server: HttpServer | HttpsServer;
 
-    if (http) {
+    if (noHttps) {
       server = createHttpServer(defaultOptions, effectiveHandler);
     } else {
       const { cert, private: key, public: ca } = await generateCertificate();
-      certificateBase64 = base64Encode(cert as PFrameInternal.PemCertificate);
+      encodedCaCert = base64Encode(cert as PFrameInternal.PemCertificate);
       server = createHttpsServer(
         { ...defaultOptions, cert, key, ca },
         effectiveHandler
       );
     }
 
-    const abortController = new AbortController();
     server
       .on('listening', () => {
         // Cast is safe by specification <https://nodejs.org/api/net.html#serveraddress>
-        const address = createObjectStoreUrl(
+        const url = createObjectStoreUrl(
           server.address() as AddressInfo,
-          http
+          noHttps
         );
         stopped = new Deferred<void>();
 
         started.resolve({
-          get address(): PFrameInternal.ObjectStoreUrl {
-            return address;
-          },
-          get authToken(): PFrameInternal.HttpAuthorizationToken | undefined {
-            return authToken;
-          },
-          get encodedCaCert():
-            | Base64Encoded<PFrameInternal.PemCertificate>
-            | undefined {
-            return certificateBase64;
+          get info(): PFrameInternal.HttpServerInfo {
+            return { url, authToken, encodedCaCert };
           },
           get stopped(): Promise<void> {
             return stopped!.promise;
           },
           stop(): Promise<void> {
-            abortController.abort();
+            server.close();
             return stopped!.promise;
           }
         });
@@ -148,8 +134,7 @@ export async function serve({
       .on('close', () => stopped?.resolve())
       .listen({
         host: 'localhost',
-        port,
-        signal: abortController.signal
+        port
       });
   } catch (error: unknown) {
     started.reject(ensureError(error));

package/src/utils/headers.ts

@@ -5,6 +5,7 @@ export const HeaderName = {
   Allow: 'allow',
   Authorization: 'authorization',
   CacheControl: 'cache-control',
+  Connection: 'connection',
   ContentLength: 'content-length',
   ContentRange: 'content-range',
   ContentType: 'content-type',
@@ -24,6 +25,7 @@ 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"'
 } as const;

package/src/utils/status.ts

@@ -7,6 +7,7 @@ export const StatusCode = {
   Unauthorized: 401, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/401>
   NotFound: 404, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/404>
   MethodNotAllowed: 405, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/405>
+  RequestTimeout: 408, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/408>
   Gone: 410, // <https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/410>
   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>