@milaboratories/pl-client 2.16.26 → 2.16.28

package/src/test/tcp-proxy.ts

@@ -1,9 +1,9 @@
-import * as net from 'node:net';
-import type { AddressInfo } from 'node:net';
-import { Transform } from 'node:stream';
-import type { TransformCallback } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
-import * as timers from 'node:timers/promises';
+import * as net from "node:net";
+import type { AddressInfo } from "node:net";
+import { Transform } from "node:stream";
+import type { TransformCallback } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import * as timers from "node:timers/promises";
 
 export type TcpProxyOptions = {
   port?: number;
@@ -39,79 +39,80 @@ export async function startTcpProxy(options: TcpProxyOptions) {
     };
     if (delayMs !== undefined) await timers.setTimeout(delayMs);
     kill();
-  };
+  }
 
-  const server = net
-    .createServer((socket: net.Socket) => {
-      const client = net.createConnection({ port: targetPort }, () => {
-        if (options.verbose) console.log(`connected to ${targetPort}`);
-      });
+  const server = net.createServer((socket: net.Socket) => {
+    const client = net.createConnection({ port: targetPort }, () => {
+      if (options.verbose) console.log(`connected to ${targetPort}`);
+    });
+
+    const pair = { socket, client };
+    connections.add(pair);
+    const onClose = () => connections.delete(pair);
+    socket.on("close", onClose);
+    client.on("close", onClose);
 
-      const pair = { socket, client };
-      connections.add(pair);
-      const onClose = () => connections.delete(pair);
-      socket.on('close', onClose);
-      client.on('close', onClose);
-
-      class LatencyTransform extends Transform {
-        private pendingTimer?: NodeJS.Timeout;
-        constructor() {
-          super();
-        }
-
-        _transform(chunk: Buffer, _enc: BufferEncoding, callback: TransformCallback) {
-          // Backpressure is respected by delaying the callback until after push
-          this.pendingTimer = setTimeout(() => {
-            this.pendingTimer = undefined;
-            this.push(chunk);
-            callback();
-          }, state.latency);
-        }
-
-        _destroy(err: Error | null, cb: (error?: Error | null) => void) {
-          if (this.pendingTimer) clearTimeout(this.pendingTimer);
+    class LatencyTransform extends Transform {
+      private pendingTimer?: NodeJS.Timeout;
+      constructor() {
+        super();
+      }
+
+      _transform(chunk: Buffer, _enc: BufferEncoding, callback: TransformCallback) {
+        // Backpressure is respected by delaying the callback until after push
+        this.pendingTimer = setTimeout(() => {
           this.pendingTimer = undefined;
-          cb(err);
-        }
+          this.push(chunk);
+          callback();
+        }, state.latency);
       }
 
-      const toClientLatency = new LatencyTransform();
-      const toTargetLatency = new LatencyTransform();
+      _destroy(err: Error | null, cb: (error?: Error | null) => void) {
+        if (this.pendingTimer) clearTimeout(this.pendingTimer);
+        this.pendingTimer = undefined;
+        cb(err);
+      }
+    }
 
-      // Bidirectional pipelines with latency and error propagation
-      pipeline(socket, toTargetLatency, client).catch((err) => {
-        socket.destroy(err);
-        client.destroy(err);
-      });
+    const toClientLatency = new LatencyTransform();
+    const toTargetLatency = new LatencyTransform();
 
-      pipeline(client, toClientLatency, socket).catch((err) => {
-        socket.destroy(err);
-        client.destroy(err);
-      });
+    // Bidirectional pipelines with latency and error propagation
+    pipeline(socket, toTargetLatency, client).catch((err) => {
+      socket.destroy(err);
+      client.destroy(err);
+    });
+
+    pipeline(client, toClientLatency, socket).catch((err) => {
+      socket.destroy(err);
+      client.destroy(err);
     });
+  });
 
   server.listen({ port: port ?? 0 }, () => {
-    console.log('Test TCP proxy server started on', server.address());
+    console.log("Test TCP proxy server started on", server.address());
   });
 
   // Wait for proxy to be ready
   await new Promise<void>((resolve, reject) => {
     if (server.listening) return resolve();
     const onError = (err: Error) => {
-      server.off('listening', onListening);
+      server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
-      server.off('error', onError);
+      server.off("error", onError);
       resolve();
     };
-    server.once('error', onError);
-    server.once('listening', onListening);
+    server.once("error", onError);
+    server.once("listening", onListening);
   });
 
   return {
     server,
-    get port() { return (server.address() as AddressInfo)?.port; },
+    get port() {
+      return (server.address() as AddressInfo)?.port;
+    },
     setLatency,
     getLatency,
     disconnectAll,

package/src/test/test_config.test.ts

@@ -1,7 +1,7 @@
-import { getTestClientConf } from './test_config';
-import { test, expect } from 'vitest';
+import { getTestClientConf } from "./test_config";
+import { test, expect } from "vitest";
 
-test('test that test config have no alternative root set', async () => {
+test("test that test config have no alternative root set", async () => {
   const { conf } = await getTestClientConf();
   expect(conf.alternativeRoot).toBeUndefined();
 });

package/src/test/test_config.ts

@@ -1,20 +1,18 @@
-import * as fs from 'node:fs';
-import { LLPlClient } from '../core/ll_client';
-import type { AuthInformation, AuthOps, PlClientConfig } from '../core/config';
-import { plAddressToConfig } from '../core/config';
-import { UnauthenticatedPlClient } from '../core/unauth_client';
-import { PlClient } from '../core/client';
-import { randomUUID } from 'node:crypto';
-import type { OptionalResourceId } from '../core/types';
-import { NullResourceId, resourceIdToString } from '../core/types';
-import { inferAuthRefreshTime } from '../core/auth';
-import * as path from 'node:path';
-import type { TestTcpProxy } from './tcp-proxy';
-import { startTcpProxy } from './tcp-proxy';
-
-export {
-  TestTcpProxy,
-};
+import * as fs from "node:fs";
+import { LLPlClient } from "../core/ll_client";
+import type { AuthInformation, AuthOps, PlClientConfig } from "../core/config";
+import { plAddressToConfig } from "../core/config";
+import { UnauthenticatedPlClient } from "../core/unauth_client";
+import { PlClient } from "../core/client";
+import { randomUUID } from "node:crypto";
+import type { OptionalResourceId } from "../core/types";
+import { NullResourceId, resourceIdToString } from "../core/types";
+import { inferAuthRefreshTime } from "../core/auth";
+import * as path from "node:path";
+import type { TestTcpProxy } from "./tcp-proxy";
+import { startTcpProxy } from "./tcp-proxy";
+
+export { TestTcpProxy };
 
 export interface TestConfig {
   address: string;
@@ -23,20 +21,20 @@ export interface TestConfig {
   test_password?: string;
 }
 
-const CONFIG_FILE = 'test_config.json';
+const CONFIG_FILE = "test_config.json";
 // const AUTH_DATA_FILE = '.test_auth.json';
 
 let authDataFilePath: string | undefined;
 
 function getFullAuthDataFilePath() {
-  if (authDataFilePath === undefined) authDataFilePath = path.resolve('.test_auth.json');
+  if (authDataFilePath === undefined) authDataFilePath = path.resolve(".test_auth.json");
   return authDataFilePath;
 }
 
 export function getTestConfig(): TestConfig {
   let conf: Partial<TestConfig> = {};
   if (fs.existsSync(CONFIG_FILE))
-    conf = JSON.parse(fs.readFileSync(CONFIG_FILE, { encoding: 'utf-8' })) as TestConfig;
+    conf = JSON.parse(fs.readFileSync(CONFIG_FILE, { encoding: "utf-8" })) as TestConfig;
 
   if (process.env.PL_ADDRESS !== undefined) conf.address = process.env.PL_ADDRESS;
 
@@ -84,7 +82,7 @@ function saveAuthInfoCallback(tConf: TestConfig): (authInformation: AuthInformat
           expiration: inferAuthRefreshTime(authInformation, 24 * 60 * 60),
         } as AuthCache),
       ),
-      'utf8',
+      "utf8",
     );
     fs.renameSync(tmpDst, dst);
   };
@@ -104,16 +102,16 @@ export async function getTestClientConf(): Promise<{ conf: PlClientConfig; auth:
   if (fs.existsSync(getFullAuthDataFilePath())) {
     try {
       const cache: AuthCache = JSON.parse(
-        fs.readFileSync(getFullAuthDataFilePath(), { encoding: 'utf-8' }),
+        fs.readFileSync(getFullAuthDataFilePath(), { encoding: "utf-8" }),
       ) as AuthCache; // TODO runtime validation
       if (
-        cache.conf.address === tConf.address
-        && cache.conf.test_user === tConf.test_user
-        && cache.conf.test_password === tConf.test_password
-        && cache.expiration > Date.now()
+        cache.conf.address === tConf.address &&
+        cache.conf.test_user === tConf.test_user &&
+        cache.conf.test_password === tConf.test_password &&
+        cache.expiration > Date.now()
       )
         authInformation = cache.authInformation;
-    } catch (_e) {
+    } catch {
       // removing cache file on any error
       fs.rmSync(getFullAuthDataFilePath());
     }
@@ -165,23 +163,23 @@ export async function getTestClient(
 ) {
   const { conf, auth } = await getTestClientConf();
   if (alternativeRoot !== undefined && conf.alternativeRoot !== undefined)
-    throw new Error('test pl address configured with alternative root');
+    throw new Error("test pl address configured with alternative root");
   return await PlClient.init({ ...conf, ...confOverrides, alternativeRoot }, auth);
 }
 
-export type WithTempRootOptions = {
-  /** If true and PL_ADDRESS is http://localhost or http://127.0.0.1:<port>,
-   * a TCP proxy will be started and PL client will connect through it. */
-  viaTcpProxy: true;
-  /** Artificial latency for proxy (ms). Default 0 */
-  proxyLatencyMs?: number;
-} | {
-  viaTcpProxy?: undefined;
-};
+export type WithTempRootOptions =
+  | {
+      /** If true and PL_ADDRESS is http://localhost or http://127.0.0.1:<port>,
+       * a TCP proxy will be started and PL client will connect through it. */
+      viaTcpProxy: true;
+      /** Artificial latency for proxy (ms). Default 0 */
+      proxyLatencyMs?: number;
+    }
+  | {
+      viaTcpProxy?: undefined;
+    };
 
-export async function withTempRoot<T>(
-  body: (pl: PlClient) => Promise<T>
-): Promise<T | void>;
+export async function withTempRoot<T>(body: (pl: PlClient) => Promise<T>): Promise<T | void>;
 
 export async function withTempRoot<T>(
   body: (pl: PlClient, proxy: Awaited<ReturnType<typeof startTcpProxy>>) => Promise<T>,
@@ -205,18 +203,21 @@ export async function withTempRoot<T>(
     if (options.viaTcpProxy === true && process.env.PL_ADDRESS) {
       try {
         const url = new URL(process.env.PL_ADDRESS);
-        const isHttp = url.protocol === 'http:';
-        const isLocal = url.hostname === '127.0.0.1' || url.hostname === 'localhost';
+        const isHttp = url.protocol === "http:";
+        const isLocal = url.hostname === "127.0.0.1" || url.hostname === "localhost";
         const port = parseInt(url.port);
         if (isHttp && isLocal && Number.isFinite(port)) {
           proxy = await startTcpProxy({ targetPort: port, latency: options.proxyLatencyMs ?? 0 });
           // Override client connection host:port to proxy
           confOverrides = { hostAndPort: `127.0.0.1:${proxy.port}` } as Partial<PlClientConfig>;
         } else {
-          console.warn('*** skipping proxy-based test, PL_ADDRESS is not localhost', process.env.PL_ADDRESS);
+          console.warn(
+            "*** skipping proxy-based test, PL_ADDRESS is not localhost",
+            process.env.PL_ADDRESS,
+          );
           return;
         }
-      } catch (_e) {
+      } catch {
         // ignore proxy setup errors; tests will run against original address
       }
     }
@@ -250,10 +251,14 @@ export async function withTempRoot<T>(
     if (proxy) {
       try {
         await proxy.disconnectAll();
-      } catch (_e) { /* ignore */ }
+      } catch {
+        /* ignore */
+      }
       try {
         await new Promise<void>((resolve) => proxy!.server.close(() => resolve()));
-      } catch (_e) { /* ignore */ }
+      } catch {
+        /* ignore */
+      }
     }
   }
 }

package/src/util/pl.ts

@@ -7,5 +7,5 @@ export type PlJWTPayload = {
 };
 
 export function parsePlJwt(token: string): PlJWTPayload {
-  return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+  return JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
 }

package/src/util/util.test.ts

@@ -1,11 +1,11 @@
-import { toBytes } from './util';
-import { test, expect } from 'vitest';
+import { toBytes } from "./util";
+import { test, expect } from "vitest";
 
-test('test toBytes 1', () => {
+test("test toBytes 1", () => {
   const arr = new Uint8Array([1, 2, 3]);
   expect(toBytes(arr)).toEqual(arr);
 });
 
-test('test toBytes 2', () => {
-  expect(toBytes('\x01\x02\x03')).toEqual(Buffer.from(new Uint8Array([1, 2, 3])));
+test("test toBytes 2", () => {
+  expect(toBytes("\x01\x02\x03")).toEqual(Buffer.from(new Uint8Array([1, 2, 3])));
 });

package/src/util/util.ts

@@ -3,7 +3,7 @@ function isArrayBufferOrView(value: unknown): value is ArrayBufferLike {
 }
 
 export function toBytes(value: string | Uint8Array): Uint8Array {
-  if (typeof value === 'string') return Buffer.from(value);
+  if (typeof value === "string") return Buffer.from(value);
   else if (isArrayBufferOrView(value)) return value;
   // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
   else throw new Error(`Unexpected type: ${value}`);

package/dist/helpers/rich_resource_types.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=rich_resource_types.d.ts.map

package/dist/helpers/rich_resource_types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rich_resource_types.d.ts","sourceRoot":"","sources":["../../src/helpers/rich_resource_types.ts"],"names":[],"mappings":""}

package/dist/helpers/smart_accessors.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=smart_accessors.d.ts.map

package/dist/helpers/smart_accessors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"smart_accessors.d.ts","sourceRoot":"","sources":["../../src/helpers/smart_accessors.ts"],"names":[],"mappings":""}

package/src/helpers/rich_resource_types.ts

@@ -1,84 +0,0 @@
-// import { ResourceType } from './types';
-//
-// //
-// // NOTE: This code is not used.
-// //       It shows a raw idea on how to implement typed Tx API
-// //
-//
-// export type AnyStructuralResourceKind = 'structural' | 'ephemeral' | 'singleton'
-// export type ResourceKind = AnyStructuralResourceKind | 'value';
-//
-// declare const __resource_type: unique symbol;
-// export type WithRichType<T, B extends ResourceType> = T & { [__resource_type]: B }
-//
-// export type Serde<V> = {
-//   ser: (obj: V) => Uint8Array
-//   des: (data: Uint8Array) => V
-// }
-//
-// export type RichResourceType<Kind extends ResourceKind,
-//   Name extends string, Version extends string, Value = never> =
-//   {
-//     kind: Kind,
-//     name: Name,
-//     version: Version,
-//     serde: Serde<Value>
-//   }
-//
-// export type AnyStructuralRichResourceType = RichResourceType<AnyStructuralResourceKind, string, string, unknown>
-//
-// const DummySerde: Serde<never> = {
-//   ser: (t) => {
-//     throw new Error();
-//   },
-//   des: (t) => {
-//     throw new Error();
-//   }
-// };
-//
-// const NoSerde = { serde: DummySerde };
-//
-// export function richStructuralType<
-//   Name extends string,
-//   Version extends string,
-//   Kind extends AnyStructuralResourceKind>(
-//   kind: Kind,
-//   name: Name,
-//   version: Version
-// ): RichResourceType<Kind, Name, Version> {
-//   return { kind, name, version, ...NoSerde };
-// }
-//
-// export function richValueType<
-//   Name extends string,
-//   Version extends string,
-//   Value>(
-//   name: Name,
-//   version: Version,
-//   serde: Serde<Value>
-// ): RichResourceType<'value', Name, Version, Value> {
-//   return { kind: 'value', name, version, serde };
-// }
-//
-// export type RichFieldType<
-//   Parent extends AnyStructuralRichResourceType,
-//   Name extends string,
-//   Ref extends AnyStructuralRichResourceType> =
-//   {
-//     parent: Parent,
-//     name: Name,
-//     referenced: Ref
-//   }
-//
-// export function richFieldType<
-//   Parent extends AnyStructuralRichResourceType,
-//   Name extends string,
-//   Ref extends AnyStructuralRichResourceType>(
-//   parent: Parent,
-//   name: Name,
-//   referenced: Ref
-// ): RichFieldType<Parent, Name, Ref> {
-//   return { parent, name, referenced };
-// }
-//
-// const BContextEnd = richStructuralType('structural', 'BContextEnd', '1');

package/src/helpers/smart_accessors.ts

@@ -1,146 +0,0 @@
-// import { FieldData, isNotNullResourceId, ResourceData, ResourceKind } from '../core/types';
-// import { AnyFieldRef, AnyResourceRef, PlTransaction, ResourceRef } from '../core/transaction';
-// import { notEmpty } from '../util/util';
-//
-// export type Serde<V> = {
-//   ser: (obj: V) => Uint8Array
-//   des: (data: Uint8Array) => V
-// }
-//
-// const DummySerde: Serde<never> = {
-//   ser: () => {
-//     throw new Error();
-//   },
-//   des: () => {
-//     throw new Error();
-//   }
-// };
-//
-// const NoSerde = { serde: DummySerde };
-//
-// export type StructuralSmartResourceKind = 'structural' | 'ephemeral'
-// export type SmartResourceKind = StructuralSmartResourceKind | 'value'
-//
-// export type SmartResourceType<Kind extends ResourceKind, Name extends string,
-//   Version extends string, Value = never> =
-//   {
-//     kind: Kind,
-//     smartKind: SmartResourceKind,
-//     name: Name,
-//     version: Version,
-//     serde: Serde<Value>
-//   }
-//
-// export type AnySmartResourceType = SmartResourceType<ResourceKind, string, string, unknown>
-// export type AnyStructuralSmartResourceType = SmartResourceType<'Structural', string, string, unknown>
-//
-// export type SmartFieldType<
-//   Parent extends AnyStructuralSmartResourceType,
-//   Ref extends AnyStructuralSmartResourceType> =
-//   {
-//     parent: Parent,
-//     name: string,
-//     referenced: Ref
-//   }
-//
-// export type AnySmartFieldType = SmartFieldType<AnyStructuralSmartResourceType, AnyStructuralSmartResourceType>;
-//
-// export function structuralValueSRT<Name extends string, Version extends string, Value>(
-//   smartKind: SmartResourceKind,
-//   name: Name,
-//   version: Version,
-//   serde: Serde<Value>
-// ): SmartResourceType<'Structural', Name, Version, Value> {
-//   return { kind: 'Structural', smartKind, name, version, serde };
-// }
-//
-// export function structuralSRT<Name extends string, Version extends string>(
-//   smartKind: SmartResourceKind,
-//   name: Name,
-//   version: Version
-// ): SmartResourceType<'Structural', Name, Version, never> {
-//   return { kind: 'Structural', smartKind, name, version, serde: DummySerde };
-// }
-//
-// export function valueSRT<Name extends string, Version extends string, Value>(
-//   name: Name,
-//   version: Version,
-//   serde: Serde<Value>
-// ): SmartResourceType<'Value', Name, Version, Value> {
-//   return { kind: 'Value', smartKind: 'value', name, version, serde };
-// }
-//
-// export function smartFields<
-//   Parent extends AnyStructuralSmartResourceType,
-//   Ref extends AnyStructuralSmartResourceType>(
-//   parent: Parent,
-//   name: string,
-//   referenced: Ref
-// ): SmartFieldType<Parent, Ref> {
-//   return { parent, name, referenced };
-// }
-//
-// export type GetValueType<ST extends AnySmartResourceType> =
-//   ST extends SmartResourceType<ResourceKind, string, string, infer X> ? X : never
-//
-// export type GetRef<SF extends AnySmartFieldType> =
-//   SF extends SmartFieldType<AnyStructuralSmartResourceType, infer X> ? X : never
-//
-// export type GetParent<SF extends AnySmartFieldType> =
-//   SF extends SmartFieldType<infer X, AnyStructuralSmartResourceType> ? X : never
-//
-// export class SmartStructuralResourceAccessor<ST extends AnyStructuralSmartResourceType> {
-//   constructor(public readonly type: ST,
-//               public readonly ref: AnyResourceRef,
-//               public readonly tx: PlTransaction) {
-//   }
-//
-//   private _resourceData?: Promise<ResourceData>;
-//
-//   public async getResourceData(): Promise<ResourceData> {
-//     if (this._resourceData === undefined)
-//       this._resourceData = this.tx.getResourceData(this.ref, true);
-//     return await this._resourceData;
-//   }
-//
-//   public async getValue(): Promise<GetValueType<ST>> {
-//     return this.type.serde.des(notEmpty((await this.getResourceData()).data)) as GetValueType<ST>;
-//   }
-//
-//   public getField<SF extends SmartFieldType<ST, AnyStructuralSmartResourceType>>(field: SF): Promise<GetValueType<ST>> {
-//     return new SmartFieldAccessor(field, { resourceId: this.ref, fieldName: field.name }, this.tx);
-//   }
-//
-// }
-//
-// export class SmartFieldAccessor<SF extends AnySmartFieldType> {
-//   constructor(public readonly descriptor: SF,
-//               public readonly ref: AnyFieldRef,
-//               public readonly tx: PlTransaction) {
-//   }
-//
-//   public parent(): SmartStructuralResourceAccessor<GetParent<SF>> {
-//     return new SmartStructuralResourceAccessor(
-//       this.descriptor.parent as GetParent<SF>,
-//       this.ref.resourceId, this.tx);
-//   }
-//
-//   private _fieldData?: Promise<FieldData>;
-//
-//   public async getFieldData(): Promise<FieldData> {
-//     if (this._fieldData === undefined)
-//       this._fieldData = this.tx.getField(this.ref);
-//     return await this._fieldData;
-//   }
-//
-//
-//   public async get(): SmartStructuralResourceAccessor<GetRef<SF>> {
-//     const fieldData = await this.getFieldData();
-//     if (isNotNullResourceId(fieldData.error))
-//       throw new Error('Error in field.');
-//     return new SmartStructuralResourceAccessor(
-//       this.descriptor.referenced as GetRef<SF>,
-//       fieldData.value,
-//       this.tx);
-//   }
-// }