@milaboratories/pl-client 2.4.10

package/src/test/test_config.test.ts

@@ -0,0 +1,6 @@
+import { getTestClientConf } from './test_config';
+
+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

@@ -0,0 +1,166 @@
+import * as fs from 'node:fs';
+import { LLPlClient } from '../core/ll_client';
+import { AuthInformation, AuthOps, plAddressToConfig, PlClientConfig } from '../core/config';
+import { UnauthenticatedPlClient } from '../core/unauth_client';
+import { PlClient } from '../core/client';
+import { randomUUID } from 'crypto';
+import { NullResourceId, OptionalResourceId, ResourceId, resourceIdToString } from '../core/types';
+import { inferAuthRefreshTime } from '../core/auth';
+import * as path from 'node:path';
+
+export interface TestConfig {
+  address: string;
+  test_proxy?: string;
+  test_user?: string;
+  test_password?: string;
+}
+
+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');
+  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' }));
+
+  if (process.env.PL_ADDRESS !== undefined) conf.address = process.env.PL_ADDRESS;
+
+  if (process.env.PL_TEST_USER !== undefined) conf.test_user = process.env.PL_TEST_USER;
+
+  if (process.env.PL_TEST_PASSWORD !== undefined) conf.test_password = process.env.PL_TEST_PASSWORD;
+
+  if (process.env.PL_TEST_PROXY !== undefined) conf.test_proxy = process.env.PL_TEST_PROXY;
+
+  if (conf.address === undefined)
+    throw new Error(
+      `can't resolve platform address (checked ${CONFIG_FILE} file and PL_ADDRESS environment var)`
+    );
+
+  return conf as TestConfig;
+}
+
+interface AuthCache {
+  /** To check if config changed */
+  conf: TestConfig;
+  expiration: number;
+  authInformation: AuthInformation;
+}
+
+function saveAuthInfoCallback(tConf: TestConfig): (authInformation: AuthInformation) => void {
+  return (authInformation) => {
+    const dst = getFullAuthDataFilePath();
+    const tmpDst = getFullAuthDataFilePath() + randomUUID();
+    fs.writeFileSync(
+      tmpDst,
+      Buffer.from(
+        JSON.stringify({
+          conf: tConf,
+          authInformation,
+          expiration: inferAuthRefreshTime(authInformation, 24 * 60 * 60)
+        } as AuthCache)
+      ),
+      'utf8'
+    );
+    fs.renameSync(tmpDst, dst);
+  };
+}
+
+const cleanAuthInfoCallback = () => {
+  console.warn(`Removing: ${getFullAuthDataFilePath()}`);
+  fs.rmSync(getFullAuthDataFilePath());
+};
+
+export async function getTestClientConf(): Promise<{ conf: PlClientConfig; auth: AuthOps }> {
+  const tConf = getTestConfig();
+
+  let authInformation: AuthInformation | undefined = undefined;
+
+  // try recover from cache
+  if (fs.existsSync(getFullAuthDataFilePath())) {
+    try {
+      const cache: AuthCache = JSON.parse(
+        fs.readFileSync(getFullAuthDataFilePath(), { encoding: 'utf-8' })
+      );
+      if (
+        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: any) {
+      // removing cache file on any error
+      fs.rmSync(getFullAuthDataFilePath());
+    }
+  }
+
+  const plConf = plAddressToConfig(tConf.address);
+
+  const uClient = new UnauthenticatedPlClient(plConf);
+
+  const requireAuth = await uClient.requireAuth();
+
+  if (!requireAuth && (tConf.test_user !== undefined || tConf.test_password !== undefined))
+    throw new Error(
+      `Server require no auth, but test user name or test password are provided via (${CONFIG_FILE}) or env variables: PL_TEST_USER and PL_TEST_PASSWORD`
+    );
+
+  if (requireAuth && (tConf.test_user === undefined || tConf.test_password === undefined))
+    throw new Error(
+      `No auth information found in config (${CONFIG_FILE}) or env variables: PL_TEST_USER and PL_TEST_PASSWORD`
+    );
+
+  if (authInformation === undefined) {
+    if (requireAuth) authInformation = await uClient.login(tConf.test_user!, tConf.test_password!);
+    // No authorization is required
+    else authInformation = {};
+
+    // saving cache
+    saveAuthInfoCallback(tConf)(authInformation);
+  }
+
+  return {
+    conf: plConf,
+    auth: {
+      authInformation,
+      onUpdate: saveAuthInfoCallback(tConf),
+      onAuthError: cleanAuthInfoCallback,
+      onUpdateError: cleanAuthInfoCallback
+    }
+  };
+}
+
+export async function getTestLLClient(confOverrides: Partial<PlClientConfig> = {}) {
+  const { conf, auth } = await getTestClientConf();
+  return new LLPlClient({ ...conf, ...confOverrides }, { auth });
+}
+
+export async function getTestClient(alternativeRoot?: string) {
+  const { conf, auth } = await getTestClientConf();
+  if (alternativeRoot !== undefined && conf.alternativeRoot !== undefined)
+    throw new Error('test pl address configured with alternative root');
+  return await PlClient.init({ ...conf, alternativeRoot }, auth);
+}
+
+export async function withTempRoot<T>(body: (pl: PlClient) => Promise<T>): Promise<T> {
+  const altRoot = `test_${Date.now()}_${randomUUID()}`;
+  let altRootId: OptionalResourceId = NullResourceId;
+  try {
+    const client = await getTestClient(altRoot);
+    altRootId = client.clientRoot;
+    const value = await body(client);
+    const rawClient = await getTestClient();
+    await rawClient.deleteAlternativeRoot(altRoot);
+    return value;
+  } catch (err: any) {
+    console.log(`ALTERNATIVE ROOT: ${altRoot} (${resourceIdToString(altRootId)})`);
+    throw new Error(err.message, { cause: err });
+  }
+}

package/src/util/branding.ts

@@ -0,0 +1,4 @@
+declare const __brand: unique symbol;
+type Brand<B> = { [__brand]: B };
+
+export type Branded<T, B> = T & Brand<B>;

package/src/util/pl.ts

@@ -0,0 +1,11 @@
+export type PlJWTPayload = {
+  user: {
+    login: string;
+  };
+  exp: number;
+  iat: number;
+};
+
+export function parsePlJwt(token: string): PlJWTPayload {
+  return JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+}

package/src/util/util.test.ts

@@ -0,0 +1,10 @@
+import { toBytes } from './util';
+
+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])));
+});

package/src/util/util.ts

@@ -0,0 +1,9 @@
+function isArrayBufferOrView(value: unknown): value is ArrayBufferLike {
+  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+
+export function toBytes(value: string | Uint8Array): Uint8Array {
+  if (typeof value === 'string') return Buffer.from(value);
+  else if (isArrayBufferOrView(value)) return value;
+  else throw new Error(`Unexpected type: ${value}`);
+}