@milaboratories/pl-drivers 1.14.16 → 1.15.0

package/src/drivers/ls.test.ts

@@ -1,10 +1,13 @@
 import { ConsoleLoggerAdapter, HmacSha256Signer } from "@milaboratories/ts-helpers";
-import { LsDriver } from "./ls";
+import { LsDriver, type LsEntryWithFileStats } from "./ls";
 import { TestHelpers } from "@milaboratories/pl-client";
 import * as path from "node:path";
-import { test, expect } from "vitest";
+import { test, expect, describe } from "vitest";
 import { isImportFileHandleIndex, isImportFileHandleUpload } from "@milaboratories/pl-model-common";
+import type { StorageHandle } from "@milaboratories/pl-model-common";
 import * as env from "../test_env";
+import { parseIndexHandle } from "./helpers/ls_remote_import_handle";
+import { createRemoteStorageHandle } from "./helpers/ls_storage_entry";
 
 const assetsPath = path.resolve("../../../assets");
 
@@ -141,3 +144,136 @@ test("should ok when get file using local dialog, and read its content", async (
     expect(multiResult.files![0]).toStrictEqual(result.file);
   });
 });
+
+// Unit tests: verify that LsDriver.listFiles and listRemoteFilesWithFileStats correctly
+// thread additionalInfo from gRPC list items into the index:// handle.
+describe("LsDriver additionalInfo threading", () => {
+  const envelope = { uid: "u1", sid: "s1", sig: "sigval", exp: "9999999999", kid: "k1", v: "1" };
+
+  const storageInfo = {
+    storageId: "test-storage",
+    storageName: "Test Storage",
+    // Signed resource id format "<globalId>|<signatureHex>" — required by asSignedResourceId.
+    resourceId: "res-id|deadbeef" as any,
+    resourceType: { name: "LS/test-storage", version: "1" },
+  };
+
+  // Builds a minimal LsDriver instance with an injected mock lsClient via private-constructor bypass.
+  function makeMockDriver(listResponse: { items: any[]; delimiter: string }): LsDriver {
+    const mockLsClient = {
+      list: async () => listResponse,
+      close: () => {},
+    };
+    const mockUserResources = {
+      getDataLibraries: async () => new Map([[storageInfo.storageId, storageInfo]]),
+    };
+    const signer = new HmacSha256Signer("test");
+    // Bypass private constructor for unit testing only.
+    return new (LsDriver as any)(
+      new ConsoleLoggerAdapter(),
+      mockLsClient,
+      mockUserResources,
+      signer,
+      new Map(),
+      new Map(),
+      () => Promise.resolve(undefined),
+    ) as LsDriver;
+  }
+
+  function makeRemoteHandle(): StorageHandle {
+    return createRemoteStorageHandle(storageInfo) as StorageHandle;
+  }
+
+  test("listFiles: handle carries additionalInfo envelope from gRPC item", async () => {
+    const driver = makeMockDriver({
+      delimiter: "/",
+      items: [
+        {
+          name: "file.txt",
+          size: 100n,
+          isDir: false,
+          additionalInfo: envelope,
+          fullName: "dir/file.txt",
+          directory: "dir/",
+          version: "v1",
+        },
+      ],
+    });
+
+    const result = await driver.listFiles(makeRemoteHandle(), "dir/");
+    expect(result.entries).toHaveLength(1);
+
+    const parsed = parseIndexHandle(result.entries[0].handle as any);
+    expect(parsed.additionalInfo).toEqual(envelope);
+  });
+
+  test("listFiles: handle has no additionalInfo when item has empty envelope", async () => {
+    const driver = makeMockDriver({
+      delimiter: "/",
+      items: [
+        {
+          name: "plain.txt",
+          size: 50n,
+          isDir: false,
+          additionalInfo: {},
+          fullName: "plain.txt",
+          directory: "",
+          version: "v1",
+        },
+      ],
+    });
+
+    const result = await driver.listFiles(makeRemoteHandle(), "");
+    expect(result.entries).toHaveLength(1);
+
+    const parsed = parseIndexHandle(result.entries[0].handle as any);
+    expect(parsed.additionalInfo).toBeUndefined();
+  });
+
+  test("listRemoteFilesWithFileStats: handle carries additionalInfo envelope", async () => {
+    const driver = makeMockDriver({
+      delimiter: "/",
+      items: [
+        {
+          name: "data.csv",
+          size: 200n,
+          isDir: false,
+          additionalInfo: envelope,
+          fullName: "data.csv",
+          directory: "",
+          version: "v2",
+        },
+      ],
+    });
+
+    const result = await driver.listRemoteFilesWithFileStats(makeRemoteHandle(), "");
+    expect(result.entries).toHaveLength(1);
+    expect((result.entries[0] as LsEntryWithFileStats).size).toBe(200);
+
+    const parsed = parseIndexHandle(result.entries[0].handle as any);
+    expect(parsed.additionalInfo).toEqual(envelope);
+  });
+
+  test("listRemoteFilesWithFileStats: no additionalInfo when absent in item", async () => {
+    const driver = makeMockDriver({
+      delimiter: "/",
+      items: [
+        {
+          name: "plain.csv",
+          size: 10n,
+          isDir: false,
+          additionalInfo: {},
+          fullName: "plain.csv",
+          directory: "",
+          version: "v1",
+        },
+      ],
+    });
+
+    const result = await driver.listRemoteFilesWithFileStats(makeRemoteHandle(), "");
+    expect(result.entries).toHaveLength(1);
+
+    const parsed = parseIndexHandle(result.entries[0].handle as any);
+    expect(parsed.additionalInfo).toBeUndefined();
+  });
+});

package/src/drivers/ls.ts

@@ -34,18 +34,18 @@ export interface InternalLsDriver extends sdk.LsDriver {
    * */
   getLocalFileHandle(localPath: string): Promise<sdk.LocalImportFileHandle>;
 
-  listRemoteFilesWithAdditionalInfo(
+  listRemoteFilesWithFileStats(
     storage: sdk.StorageHandle,
     fullPath: string,
-  ): Promise<ListRemoteFilesResultWithAdditionalInfo>;
+  ): Promise<ListRemoteFilesResultWithFileStats>;
 }
 
-export type ListRemoteFilesResultWithAdditionalInfo = {
+export type ListRemoteFilesResultWithFileStats = {
   parent?: string;
-  entries: LsEntryWithAdditionalInfo[];
+  entries: LsEntryWithFileStats[];
 };
 
-export type LsEntryWithAdditionalInfo = sdk.LsEntry & {
+export type LsEntryWithFileStats = sdk.LsEntry & {
   size: number;
 };
 
@@ -217,7 +217,7 @@ export class LsDriver implements InternalLsDriver {
           type: e.isDir ? "dir" : "file",
           name: e.name,
           fullPath: e.fullName,
-          handle: createIndexImportHandle(storageData.storageId, e.fullName),
+          handle: createIndexImportHandle(storageData.storageId, e.fullName, e.additionalInfo),
         })),
       };
     }
@@ -249,10 +249,10 @@ export class LsDriver implements InternalLsDriver {
     return { entries };
   }
 
-  public async listRemoteFilesWithAdditionalInfo(
+  public async listRemoteFilesWithFileStats(
     storageHandle: sdk.StorageHandle,
     fullPath: string,
-  ): Promise<ListRemoteFilesResultWithAdditionalInfo> {
+  ): Promise<ListRemoteFilesResultWithFileStats> {
     const storageData = parseStorageHandle(storageHandle);
     if (!storageData.isRemote) {
       throw new Error(`Storage ${storageData.name} is not remote`);
@@ -266,7 +266,7 @@ export class LsDriver implements InternalLsDriver {
         type: e.isDir ? "dir" : "file",
         name: e.name,
         fullPath: e.fullName,
-        handle: createIndexImportHandle(storageData.storageId, e.fullName),
+        handle: createIndexImportHandle(storageData.storageId, e.fullName, e.additionalInfo),
         size: Number(e.size),
       })),
     };

package/src/drivers/types.ts

@@ -54,6 +54,11 @@ export const ImportFileHandleIndexData = z.object({
   storageId: z.string(),
   /** Path inside storage */
   path: z.string(),
+  /**
+   * Federative identity envelope from LsAPI.List.Response.ListItem.additional_info.
+   * Absent for non-federative storages (backwards compatible: old handles parse unchanged).
+   */
+  additionalInfo: z.record(z.string(), z.string()).optional(),
 });
 export type ImportFileHandleIndexData = z.infer<typeof ImportFileHandleIndexData>;
 

package/src/proto-grpc/github.com/milaboratory/pl/controllers/shared/grpc/lsapi/protocol.ts

@@ -40,6 +40,16 @@ export interface LsAPI_ListItem {
      * @generated from protobuf field: bool is_dir = 3
      */
     isDir: boolean;
+    /**
+     * additional_info carries the signed identity envelope for federative storages.
+     * KV schema: v=1, path, uid, sid, role, exp, kid, signed, sig.
+     * Empty for non-federative storages. Verifiers MUST ignore unknown keys.
+     *
+     * @generated from protobuf field: map<string, string> additional_info = 8
+     */
+    additionalInfo: {
+        [key: string]: string;
+    };
     /**
      * full_name is the full name of the item, relative to the storage root.
      * It is <directory> + <name>.
@@ -169,6 +179,7 @@ class LsAPI_ListItem$Type extends MessageType<LsAPI_ListItem> {
             { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "size", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
             { no: 3, name: "is_dir", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "additional_info", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } },
             { no: 10, name: "full_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 11, name: "directory", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 12, name: "last_modified", kind: "message", T: () => Timestamp },
@@ -180,6 +191,7 @@ class LsAPI_ListItem$Type extends MessageType<LsAPI_ListItem> {
         message.name = "";
         message.size = 0n;
         message.isDir = false;
+        message.additionalInfo = {};
         message.fullName = "";
         message.directory = "";
         message.version = "";
@@ -201,6 +213,9 @@ class LsAPI_ListItem$Type extends MessageType<LsAPI_ListItem> {
                 case /* bool is_dir */ 3:
                     message.isDir = reader.bool();
                     break;
+                case /* map<string, string> additional_info */ 8:
+                    this.binaryReadMap8(message.additionalInfo, reader, options);
+                    break;
                 case /* string full_name */ 10:
                     message.fullName = reader.string();
                     break;
@@ -224,6 +239,22 @@ class LsAPI_ListItem$Type extends MessageType<LsAPI_ListItem> {
         }
         return message;
     }
+    private binaryReadMap8(map: LsAPI_ListItem["additionalInfo"], reader: IBinaryReader, options: BinaryReadOptions): void {
+        let len = reader.uint32(), end = reader.pos + len, key: keyof LsAPI_ListItem["additionalInfo"] | undefined, val: LsAPI_ListItem["additionalInfo"][any] | undefined;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for MiLaboratories.Controller.Shared.LsAPI.ListItem.additional_info");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
     internalBinaryWrite(message: LsAPI_ListItem, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
         /* string name = 1; */
         if (message.name !== "")
@@ -234,6 +265,9 @@ class LsAPI_ListItem$Type extends MessageType<LsAPI_ListItem> {
         /* bool is_dir = 3; */
         if (message.isDir !== false)
             writer.tag(3, WireType.Varint).bool(message.isDir);
+        /* map<string, string> additional_info = 8; */
+        for (let k of globalThis.Object.keys(message.additionalInfo))
+            writer.tag(8, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.additionalInfo[k]).join();
         /* string full_name = 10; */
         if (message.fullName !== "")
             writer.tag(10, WireType.LengthDelimited).string(message.fullName);

package/src/proto-rest/lsapi.ts

@@ -41,6 +41,14 @@ export interface components {
       size: string;
       /** @description is_dir is true for an item that can have subitems. */
       isDir: boolean;
+      /**
+       * @description additional_info carries the signed identity envelope for federative storages.
+       *      KV schema: v=1, path, uid, sid, role, exp, kid, signed, sig.
+       *      Empty for non-federative storages. Verifiers MUST ignore unknown keys.
+       */
+      additionalInfo?: {
+        [key: string]: string;
+      };
       /**
        * @description full_name is the full name of the item, relative to the storage root.
        *      It is <directory> + <name>.