@milaboratories/pl-client 3.2.5 → 3.3.0

package/src/core/final.ts

@@ -1,6 +1,6 @@
 import type { Optional } from "utility-types";
 import type { BasicResourceData, ResourceData } from "./types";
-import { getField, isNotNullResourceId, isNullResourceId } from "./types";
+import { getField, isNotNullSignedResourceId, isNullSignedResourceId } from "./types";
 import { ResourceTypeName, ResourceTypePrefix } from "@milaboratories/pl-model-common";
 export { ResourceTypeName, ResourceTypePrefix };
 
@@ -19,7 +19,9 @@ export type FinalResourceDataPredicate = (
 
 function readyOrDuplicateOrError(r: ResourceData | BasicResourceData): boolean {
   return (
-    r.resourceReady || isNotNullResourceId(r.originalResourceId) || isNotNullResourceId(r.error)
+    r.resourceReady ||
+    isNotNullSignedResourceId(r.originalResourceId) ||
+    isNotNullSignedResourceId(r.error)
   );
 }
 
@@ -28,7 +30,8 @@ function readyAndHasAllOutputsFilled(r: Optional<ResourceData, "fields">): boole
   if (!r.outputsLocked) return false;
   if (r.fields === undefined) return true; // if fields are not provided basic resource state is not expected to change in the future
   for (const f of r.fields)
-    if (isNullResourceId(f.error) && (isNullResourceId(f.value) || !f.valueIsFinal)) return false;
+    if (isNullSignedResourceId(f.error) && (isNullSignedResourceId(f.value) || !f.valueIsFinal))
+      return false;
   return true;
 }
 
@@ -41,7 +44,7 @@ export const DefaultFinalResourceDataPredicate: FinalResourceDataPredicate = (r)
     case ResourceTypeName.StreamManager: {
       if (!readyOrDuplicateOrError(r)) return false;
       if (r.fields === undefined) return true; // if fields are not provided basic resource state is not expected to change in the future
-      if (isNotNullResourceId(r.error)) return true;
+      if (isNotNullSignedResourceId(r.error)) return true;
       const downloadable = getField(r as ResourceData, "downloadable");
       const stream = getField(r as ResourceData, "stream");
       return stream.value === downloadable.value;
@@ -79,14 +82,21 @@ export const DefaultFinalResourceDataPredicate: FinalResourceDataPredicate = (r)
     case ResourceTypeName.Null:
     case ResourceTypeName.Binary:
     case ResourceTypeName.LSProvider:
+    case ResourceTypeName.WorkingDirectory:
       return true;
     case ResourceTypeName.UserProject:
     case ResourceTypeName.Projects:
     case ResourceTypeName.ClientRoot:
       return false;
     default:
-      if (r.type.name.startsWith(ResourceTypePrefix.Blob)) return true;
-      else if (
+      if (
+        r.type.name.startsWith(ResourceTypePrefix.Blob) ||
+        r.type.name.startsWith(ResourceTypePrefix.LS) ||
+        r.type.name.startsWith(ResourceTypePrefix.WorkingDirectory) ||
+        r.type.name.startsWith(ResourceTypePrefix.StorageSpaceAllocation)
+      ) {
+        return true;
+      } else if (
         r.type.name.startsWith(ResourceTypePrefix.BlobUpload) ||
         r.type.name.startsWith(ResourceTypePrefix.BlobIndex)
       ) {

package/src/core/ll_client.ts

@@ -35,7 +35,7 @@ import { notEmpty, retry, withTimeout, type RetryOptions } from "@milaboratories
 import { Code } from "../proto-grpc/google/rpc/code";
 import { WebSocketBiDiStream } from "./websocket_stream";
 import {
-  AuthAPI_GetJWTToken_Role,
+  AuthAPI_Role,
   TxAPI_ClientMessage,
   TxAPI_ServerMessage,
 } from "../proto-grpc/github.com/milaboratory/pl/plapi/plapiproto/api";
@@ -463,10 +463,10 @@ export class LLPlClient implements WireClientProviderFactory {
 
   public async getJwtToken(
     ttlSeconds: bigint,
-    options?: { authorization?: string; role?: AuthAPI_GetJWTToken_Role },
+    options?: { authorization?: string; role?: AuthAPI_Role },
   ): Promise<string> {
     const cl = this.clientProvider.get();
-    const role = options?.role ?? AuthAPI_GetJWTToken_Role.ROLE_UNSPECIFIED;
+    const role = options?.role ?? AuthAPI_Role.UNSPECIFIED;
 
     if (cl instanceof GrpcPlApiClient) {
       const meta: Record<string, string> = {};
@@ -592,6 +592,42 @@ export class LLPlClient implements WireClientProviderFactory {
     }
   }
 
+  public async getUserRoot(
+    opts: { login?: string; doNotCreate?: boolean } = {},
+  ): Promise<grpcTypes.AuthAPI_GetUserRoot_Response> {
+    const cl = this.clientProvider.get();
+    if (cl instanceof GrpcPlApiClient) {
+      return (
+        await cl.getUserRoot({
+          login: opts.login ?? "",
+          doNotCreate: opts.doNotCreate ?? false,
+        })
+      ).response;
+    } else {
+      const resp = notEmpty(
+        (
+          await cl.POST("/v1/auth/user-root", {
+            body: {
+              login: opts.login ?? "",
+              doNotCreate: opts.doNotCreate ?? false,
+            },
+          })
+        ).data,
+        "REST: empty response for getUserRoot request",
+      );
+      return {
+        userRoot: resp.userRoot
+          ? {
+              resourceId: BigInt(resp.userRoot.resourceId),
+              resourceSignature: Uint8Array.from(
+                Buffer.from(resp.userRoot.resourceSignature, "base64"),
+              ),
+            }
+          : undefined,
+      };
+    }
+  }
+
   public async listUserResources(
     opts: { login?: string; startFrom?: bigint; limit?: number } = {},
   ): Promise<grpcTypes.AuthAPI_ListUserResources_Response[]> {

package/src/core/ll_transaction.test.ts

@@ -6,6 +6,23 @@ import { test, expect } from "vitest";
 import { isTimeoutOrCancelError } from "./errors";
 import { Aborted } from "@milaboratories/ts-helpers";
 
+/** Cached root signature — fetched once, shared across tests. */
+let cachedRootSig: Uint8Array | undefined;
+
+async function getRootSignature(): Promise<Uint8Array> {
+  if (cachedRootSig !== undefined) return cachedRootSig;
+  const client = await getTestLLClient();
+  const responses = await client.listUserResources({ limit: 1 });
+  for (const msg of responses) {
+    if (msg.entry.oneofKind === "userRoot" && msg.entry.userRoot.resourceSignature) {
+      cachedRootSig = msg.entry.userRoot.resourceSignature;
+      return cachedRootSig;
+    }
+  }
+  cachedRootSig = new Uint8Array(0);
+  return cachedRootSig;
+}
+
 test("check successful transaction", async () => {
   const client = await getTestLLClient();
   const tx = client.createTx(true);
@@ -80,6 +97,7 @@ test("check timeout error type (passive)", async () => {
 
 test("check timeout error type (active)", async () => {
   const client = await getTestLLClient();
+  const rootSig = await getRootSignature();
   const tx = client.createTx(true, { timeout: 500 });
 
   try {
@@ -96,6 +114,12 @@ test("check timeout error type (active)", async () => {
     );
     expect(openResponse.txOpen.tx?.isValid).toBeTruthy();
 
+    // Set default color so resource creation succeeds in strict mode
+    await tx.send(
+      { oneofKind: "setDefaultColor", setDefaultColor: { colorProof: rootSig } },
+      false,
+    );
+
     const rData = Uint8Array.from([
       (Math.random() * 256) & 0xff,
       (Math.random() * 256) & 0xff,
@@ -112,15 +136,17 @@ test("check timeout error type (active)", async () => {
         oneofKind: "resourceCreateValue",
         resourceCreateValue: {
           id: createLocalResourceId(false, 1, 1),
+          colorProof: new Uint8Array(0),
           type: { name: "TestValue", version: "1" },
           data: rData,
           errorIfExists: false,
-          colorProof: new Uint8Array(0),
         },
       },
       false,
     );
-    const id = (await createResponse).resourceCreateValue.resourceId;
+    const createResp = (await createResponse).resourceCreateValue;
+    const id = createResp.resourceId;
+    const resourceSignature = createResp.resourceSignature ?? new Uint8Array(0);
 
     while (true) {
       const vr = await tx.send(
@@ -129,7 +155,7 @@ test("check timeout error type (active)", async () => {
           resourceGet: {
             resourceId: id,
             loadFields: false,
-            resourceSignature: new Uint8Array(0),
+            resourceSignature,
           },
         },
         false,
@@ -144,6 +170,7 @@ test("check timeout error type (active)", async () => {
 
 test("check is abort error (active)", async () => {
   const client = await getTestLLClient();
+  const rootSig = await getRootSignature();
   const tx = client.createTx(true, { abortSignal: AbortSignal.timeout(100) });
 
   try {
@@ -160,6 +187,12 @@ test("check is abort error (active)", async () => {
     );
     expect(openResponse.txOpen.tx?.isValid).toBeTruthy();
 
+    // Set default color so resource creation succeeds in strict mode
+    await tx.send(
+      { oneofKind: "setDefaultColor", setDefaultColor: { colorProof: rootSig } },
+      false,
+    );
+
     const rData = Uint8Array.from([
       Math.random() & 0xff,
       Math.random() & 0xff,
@@ -178,13 +211,15 @@ test("check is abort error (active)", async () => {
           id: createLocalResourceId(false, 1, 1),
           type: { name: "TestValue", version: "1" },
           data: rData,
-          errorIfExists: false,
           colorProof: new Uint8Array(0),
+          errorIfExists: false,
         },
       },
       false,
     );
-    const id = (await createResponse).resourceCreateValue.resourceId;
+    const createResp = (await createResponse).resourceCreateValue;
+    const id = createResp.resourceId;
+    const resourceSignature = createResp.resourceSignature ?? new Uint8Array(0);
 
     while (true) {
       const vr = await tx.send(
@@ -193,7 +228,7 @@ test("check is abort error (active)", async () => {
           resourceGet: {
             resourceId: id,
             loadFields: false,
-            resourceSignature: new Uint8Array(0),
+            resourceSignature,
           },
         },
         false,