@milaboratories/pl-client 2.9.2 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@milaboratories/pl-client",
-  "version": "2.9.2",
+  "version": "2.10.0",
   "engines": {
     "node": ">=20.3.0"
   },

package/src/core/error_resource.ts

@@ -0,0 +1,10 @@
+import type { ResourceType } from './types';
+
+export type ErrorResourceData = {
+  message: string;
+};
+
+export const ErrorResourceType: ResourceType = {
+  name: 'json/resourceError',
+  version: '1',
+};

package/src/core/errors.ts

@@ -36,6 +36,7 @@ export function isTimeoutOrCancelError(err: unknown, nested: boolean = false): b
 export const PlErrorCodeNotFound = 5;
 
 export class PlError extends Error {
+  name = 'PlError';
   constructor(public readonly status: Status) {
     super(`code=${status.code} ${status.message}`);
   }
@@ -46,12 +47,14 @@ export function throwPlNotFoundError(message: string): never {
 }
 
 export class RecoverablePlError extends PlError {
+  name = 'RecoverablePlError';
   constructor(status: Status) {
     super(status);
   }
 }
 
 export class UnrecoverablePlError extends PlError {
+  name = 'UnrecoverablePlError';
   constructor(status: Status) {
     super(status);
   }
@@ -64,12 +67,14 @@ export function isNotFoundError(err: unknown, nested: boolean = false): boolean
 }
 
 export class UnauthenticatedError extends Error {
+  name = 'UnauthenticatedError';
   constructor(message: string) {
     super('LoginFailed: ' + message);
   }
 }
 
 export class DisconnectedError extends Error {
+  name = 'DisconnectedError';
   constructor(message: string) {
     super('Disconnected: ' + message);
   }

package/src/core/transaction.ts

@@ -36,6 +36,8 @@ import type { LRUCache } from 'lru-cache';
 import type { ResourceDataCacheRecord } from './cache';
 import type { TxStat } from './stat';
 import { initialTxStat } from './stat';
+import type { ErrorResourceData } from './error_resource';
+import { ErrorResourceType } from './error_resource';
 
 /** Reference to resource, used only within transaction */
 export interface ResourceRef {
@@ -440,6 +442,10 @@ export class PlTransaction {
     );
   }
 
+  public createError(message: string): ResourceRef {
+    return this.createValue(ErrorResourceType, JSON.stringify({ message } satisfies ErrorResourceData));
+  }
+
   public setResourceName(name: string, rId: AnyResourceRef): void {
     this.sendVoidAsync({
       oneofKind: 'resourceNameSet',
@@ -630,6 +636,13 @@ export class PlTransaction {
     this.lockOutputs(rID);
   }
 
+  public setResourceError(rId: AnyResourceRef, ref: AnyResourceRef): void {
+    this.sendVoidAsync({
+      oneofKind: 'resourceSetError',
+      resourceSetError: { resourceId: toResourceId(rId), errorResourceId: toResourceId(ref) },
+    });
+  }
+
   //
   // Fields
   //

package/src/test/test_config.ts

@@ -152,17 +152,17 @@ export async function getTestClient(alternativeRoot?: string) {
 }
 
 export async function withTempRoot<T>(body: (pl: PlClient) => Promise<T>): Promise<T> {
-  const altRoot = `test_${Date.now()}_${randomUUID()}`;
+  const alternativeRoot = `test_${Date.now()}_${randomUUID()}`;
   let altRootId: OptionalResourceId = NullResourceId;
   try {
-    const client = await getTestClient(altRoot);
+    const client = await getTestClient(alternativeRoot);
     altRootId = client.clientRoot;
     const value = await body(client);
     const rawClient = await getTestClient();
-    await rawClient.deleteAlternativeRoot(altRoot);
+    await rawClient.deleteAlternativeRoot(alternativeRoot);
     return value;
   } catch (err: any) {
-    console.log(`ALTERNATIVE ROOT: ${altRoot} (${resourceIdToString(altRootId)})`);
+    console.log(`ALTERNATIVE ROOT: ${alternativeRoot} (${resourceIdToString(altRootId)})`);
     throw new Error(err.message, { cause: err });
   }
 }