@seliseblocks/cli-os 0.2.2 → 0.2.3

package/dist/commands/data/files/object-tree.js

@@ -0,0 +1,238 @@
+import { booleanFlag, optionalBooleanFlag, optionalIntegerFlag, stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { confirmMutation } from "../../../lib/confirm.js";
+import { compact, jsonBodyFlag, listFlag } from "../../../lib/json-flag.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function dataFilesList(argv) {
+    const { flags } = parseCommand(argv);
+    await read("/data/v4/objects/get-objects", flags, compact({
+        cursor: stringFlag(flags, "cursor") || undefined,
+        limit: optionalIntegerFlag(flags, "limit"),
+        moduleName: optionalIntegerFlag(flags, "module-name"),
+        parentDirectoryId: parentId(flags) || undefined,
+        search: stringFlag(flags, "search") || undefined,
+        type: stringFlag(flags, "type") || undefined
+    }));
+}
+export async function dataFilesSearch(argv) {
+    const { args, flags } = parseCommand(argv);
+    await read("/data/v4/objects/search-objects", flags, compact({
+        cursor: stringFlag(flags, "cursor") || undefined,
+        directoryId: stringFlag(flags, "directory-id") || undefined,
+        limit: optionalIntegerFlag(flags, "limit"),
+        query: args[0] || stringFlag(flags, "query", { required: true }),
+        type: stringFlag(flags, "type") || undefined
+    }));
+}
+export async function dataFilesTrash(argv) {
+    const { flags } = parseCommand(argv);
+    await read("/data/v4/objects/get-trash", flags, pageQuery(flags));
+}
+export async function dataFilesShared(argv) {
+    const { flags } = parseCommand(argv);
+    await read("/data/v4/objects/get-shared-objects", flags, pageQuery(flags));
+}
+export async function dataFilesRestore(argv) {
+    const { args, flags } = parseCommand(argv);
+    const resourceId = resourceArg(args, flags);
+    await mutate("/data/v4/objects/restore-from-trash", flags, { resourceId }, `Restore storage object '${resourceId}' from trash.`);
+}
+export async function dataFilesPurge(argv) {
+    const { args, flags } = parseCommand(argv);
+    const resourceId = resourceArg(args, flags);
+    await mutate("/data/v4/objects/delete-from-trash", flags, { resourceId }, `Permanently delete storage object '${resourceId}' from trash.`);
+}
+export async function dataFilesDirectoryCreate(argv) {
+    const { args, flags } = parseCommand(argv);
+    const base = await jsonBodyFlag(flags);
+    const name = args[0] || stringFlag(flags, "name") || String(base.name ?? "");
+    if (!name)
+        throw new Error("Provide a directory name as the first argument or --name.");
+    const body = { ...base, ...compact({
+            allowedFileExtensions: listFlag(flags, "allowed-extensions"),
+            configurationName: stringFlag(flags, "configuration-name") || undefined,
+            description: stringFlag(flags, "description") || undefined,
+            moduleName: optionalIntegerFlag(flags, "module-name"),
+            name,
+            parentDirectoryId: parentId(flags) || undefined
+        }) };
+    await mutate("/data/v4/directory/create-directory", flags, body, `Create storage directory '${name}'.`);
+}
+export async function dataFilesDirectoryGet(argv) {
+    const { args, flags } = parseCommand(argv);
+    const directoryId = directoryArg(args, flags);
+    await read("/data/v4/directory/get-directory", flags, { directoryId });
+}
+export async function dataFilesDirectoryUpdate(argv) {
+    const { args, flags } = parseCommand(argv);
+    const directoryId = directoryArg(args, flags);
+    const body = { ...(await jsonBodyFlag(flags)), ...compact({
+            description: stringFlag(flags, "description") || undefined,
+            directoryId,
+            name: stringFlag(flags, "name") || undefined
+        }) };
+    await mutate("/data/v4/directory/update-directory", flags, body, `Update storage directory '${directoryId}'.`);
+}
+export async function dataFilesDirectoryDelete(argv) {
+    const { args, flags } = parseCommand(argv);
+    const directoryId = directoryArg(args, flags);
+    const permanent = booleanFlag(flags, "permanent");
+    await mutate("/data/v4/directory/delete-directory", flags, { directoryId, permanent }, `${permanent ? "Permanently delete" : "Move"} storage directory '${directoryId}'${permanent ? "" : " to trash"}.`);
+}
+export async function dataFilesDirectoryMove(argv) {
+    const { args, flags } = parseCommand(argv);
+    const directoryId = directoryArg(args, flags);
+    const targetDirectoryId = stringFlag(flags, "target-directory-id") || stringFlag(flags, "target-id");
+    await mutate("/data/v4/directory/move-directory", flags, { directoryId, targetDirectoryId }, `Move storage directory '${directoryId}'.`);
+}
+export async function dataFilesVersions(argv) {
+    const { args, flags } = parseCommand(argv);
+    await read("/data/v4/files/get-file-versions", flags, compact({
+        cursor: stringFlag(flags, "cursor") || undefined,
+        fileId: fileArg(args, flags),
+        limit: optionalIntegerFlag(flags, "limit")
+    }));
+}
+export async function dataFilesCreateVersion(argv) {
+    const { args, flags } = parseCommand(argv);
+    const fileId = fileArg(args, flags);
+    await mutate("/data/v4/files/create-file-version", flags, compact({
+        configurationName: stringFlag(flags, "configuration-name") || undefined,
+        fileId
+    }), `Create a new upload version for file '${fileId}'.`);
+}
+export async function dataFilesCopy(argv) {
+    const { args, flags } = parseCommand(argv);
+    const fileId = fileArg(args, flags);
+    const targetDirectoryId = stringFlag(flags, "target-directory-id", { required: true });
+    await mutate("/data/v4/files/copy-file", flags, {
+        copyAccessPolicies: booleanFlag(flags, "copy-access-policies"), fileId, targetDirectoryId
+    }, `Copy file '${fileId}' to directory '${targetDirectoryId}'.`);
+}
+export async function dataFilesMove(argv) {
+    const { args, flags } = parseCommand(argv);
+    const fileId = fileArg(args, flags);
+    const targetDirectoryId = stringFlag(flags, "target-directory-id", { required: true });
+    await mutate("/data/v4/files/move-file", flags, { fileId, targetDirectoryId }, `Move file '${fileId}' to directory '${targetDirectoryId}'.`);
+}
+export async function dataFilesRename(argv) {
+    const { args, flags } = parseCommand(argv);
+    const fileId = fileArg(args, flags);
+    const name = stringFlag(flags, "name", { required: true });
+    await mutate("/data/v4/files/rename-file", flags, { fileId, name }, `Rename file '${fileId}' to '${name}'.`);
+}
+export async function dataFilesAccessList(argv) {
+    const { args, flags } = parseCommand(argv);
+    await read("/data/v4/objects/get-access-policies", flags, { resourceId: resourceArg(args, flags) });
+}
+export async function dataFilesAccessGrant(argv) {
+    await accessMutation(argv, "/data/v4/objects/grant-access", "Grant access to");
+}
+export async function dataFilesAccessUpdate(argv) {
+    await accessMutation(argv, "/data/v4/objects/update-access-policy", "Update access on", true);
+}
+export async function dataFilesAccessRevoke(argv) {
+    const { args, flags } = parseCommand(argv);
+    const resourceId = resourceArg(args, flags);
+    const policyItemId = stringFlag(flags, "policy-id", { required: true });
+    await mutate("/data/v4/objects/revoke-access-policy", flags, { policyItemId, resourceId }, `Revoke access policy '${policyItemId}' from '${resourceId}'.`);
+}
+export async function dataFilesAccessResolve(argv) {
+    const { args, flags } = parseCommand(argv);
+    await read("/data/v4/objects/resolve-access", flags, { resourceId: resourceArg(args, flags) });
+}
+export async function dataFilesInheritance(argv) {
+    const { args, flags } = parseCommand(argv);
+    const base = await jsonBodyFlag(flags);
+    const value = optionalBooleanFlag(flags, "enabled");
+    const inheritsParentAccess = value ?? base.inheritsParentAccess;
+    if (typeof inheritsParentAccess !== "boolean")
+        throw new Error("Provide --enabled=true|false.");
+    const resourceId = resourceArg(args, flags, base);
+    await mutate("/data/v4/objects/toggle-inheritance", flags, { ...base, inheritsParentAccess, resourceId }, `Set inheritance on '${resourceId}' to ${inheritsParentAccess}.`);
+}
+export async function dataFilesShare(argv) {
+    const { args, flags } = parseCommand(argv);
+    const base = await jsonBodyFlag(flags);
+    const resourceId = resourceArg(args, flags, base);
+    const body = accessBody(base, flags, resourceId);
+    delete body.effect;
+    delete body.policyItemId;
+    await mutate("/data/v4/objects/share-object", flags, body, `Share storage object '${resourceId}'.`);
+}
+async function accessMutation(argv, endpoint, action, update = false) {
+    const { args, flags } = parseCommand(argv);
+    const base = await jsonBodyFlag(flags);
+    const resourceId = resourceArg(args, flags, base);
+    const body = accessBody(base, flags, resourceId);
+    if (update && !body.policyItemId)
+        throw new Error("Provide --policy-id when updating an access policy.");
+    await mutate(endpoint, flags, body, `${action} storage object '${resourceId}'.`);
+}
+function accessBody(base, flags, resourceId) {
+    const body = { ...base, ...compact({
+            effect: stringFlag(flags, "effect") || undefined,
+            expiresAt: stringFlag(flags, "expires-at") || undefined,
+            permission: stringFlag(flags, "permission") || undefined,
+            policyItemId: stringFlag(flags, "policy-id") || undefined,
+            principalId: stringFlag(flags, "principal-id") || undefined,
+            principalType: stringFlag(flags, "principal-type") || undefined,
+            priority: optionalIntegerFlag(flags, "priority"),
+            resourceId,
+            resourceType: stringFlag(flags, "resource-type") || undefined
+        }) };
+    for (const field of ["permission", "principalType", "resourceType"]) {
+        if (!body[field])
+            throw new Error(`Provide --${field.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}.`);
+    }
+    return body;
+}
+async function read(endpoint, flags, query) {
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest(endpoint, {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query
+    });
+    writeOutput(result, flags);
+}
+async function mutate(endpoint, flags, body, prompt) {
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint, request: body }, flags);
+        return;
+    }
+    await confirmMutation(flags, prompt);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest(endpoint, {
+        body,
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}
+function pageQuery(flags) {
+    return compact({
+        cursor: stringFlag(flags, "cursor") || undefined,
+        limit: optionalIntegerFlag(flags, "limit"),
+        type: stringFlag(flags, "type") || undefined
+    });
+}
+function parentId(flags) {
+    return stringFlag(flags, "parent-directory-id") || stringFlag(flags, "parent-id");
+}
+function resourceArg(args, flags, base = {}) {
+    const value = args[0] || stringFlag(flags, "resource-id") || String(base.resourceId ?? "");
+    if (!value)
+        throw new Error("Provide a resource id as the first argument or --resource-id.");
+    return value;
+}
+function directoryArg(args, flags) {
+    return args[0] || stringFlag(flags, "directory-id", { required: true });
+}
+function fileArg(args, flags) {
+    return args[0] || stringFlag(flags, "file-id", { required: true });
+}

package/dist/commands/data/files/presigned-upload-url.js

@@ -1,5 +1,6 @@
-import { optionalIntegerFlag, stringFlag } from "../../../lib/args.js";
+import { booleanFlag, optionalIntegerFlag, stringFlag } from "../../../lib/args.js";
 import { blocksRequest } from "../../../lib/api.js";
+import { confirmMutation } from "../../../lib/confirm.js";
 import { compact, jsonBodyFlag } from "../../../lib/json-flag.js";
 import { writeOutput } from "../../../lib/output.js";
 import { requestContext } from "../../../lib/request-context.js";
@@ -16,6 +17,7 @@ export async function dataFilesPresignedUploadUrl(argv) {
         ...compact({
             accessModifier: stringFlag(flags, "access-modifier") || undefined,
             configurationName: stringFlag(flags, "configuration-name") || undefined,
+            itemId: stringFlag(flags, "item-id") || undefined,
             metaData: stringFlag(flags, "meta-data") || undefined,
             moduleName: optionalIntegerFlag(flags, "module-name"),
             name: stringFlag(flags, "name", { required: true }),
@@ -23,8 +25,13 @@ export async function dataFilesPresignedUploadUrl(argv) {
             tags: stringFlag(flags, "tags") || undefined
         })
     };
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: "/data/v4/files/get-pre-signed-url-for-upload", request: body }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Create file metadata and an upload URL for '${body.name}'.`);
     const projectKey = await selectedProject(flags);
-    const result = await blocksRequest("/data/v4/Files/GetPreSignedUrlForUpload", {
+    const result = await blocksRequest("/data/v4/files/get-pre-signed-url-for-upload", {
         body,
         impersonatedProjectAuth: true,
         ...requestContext(flags),

package/dist/commands/data/files/update-additional-info.js

@@ -11,12 +11,12 @@ export async function dataFilesUpdateAdditionalInfo(argv) {
     const additionalProperties = JSON.parse(additionalPropertiesRaw);
     const body = { additionalProperties, itemId };
     if (booleanFlag(flags, "dry-run")) {
-        writeOutput({ dryRun: true, endpoint: "/data/v4/Files/UpdateFileAdditionalInfo", request: body }, flags);
+        writeOutput({ dryRun: true, endpoint: "/data/v4/files/update-file-additional-info", request: body }, flags);
         return;
     }
     await confirmMutation(flags, `Update additional info for file '${itemId}'.`);
     const projectKey = await selectedProject(flags);
-    const result = await blocksRequest("/data/v4/Files/UpdateFileAdditionalInfo", {
+    const result = await blocksRequest("/data/v4/files/update-file-additional-info", {
         body,
         impersonatedProjectAuth: true,
         ...requestContext(flags),

package/dist/commands/data/files/upload-to-local-storage.js

@@ -16,7 +16,7 @@ export async function dataFilesUploadToLocalStorage(argv) {
     const name = stringFlag(flags, "name") || basename(filePath);
     const additionalPropertiesRaw = stringFlag(flags, "additional-properties");
     if (booleanFlag(flags, "dry-run")) {
-        writeOutput({ dryRun: true, endpoint: "/data/v4/Files/UploadFileToLocalStorage", name, request: { file: filePath } }, flags);
+        writeOutput({ dryRun: true, endpoint: "/data/v4/files/upload-file-to-local-storage", name, request: { file: filePath } }, flags);
         return;
     }
     await confirmMutation(flags, `Upload '${filePath}' to local storage as '${name}'.`);
@@ -45,7 +45,7 @@ export async function dataFilesUploadToLocalStorage(argv) {
             form.set(`AdditionalProperties[${key}]`, value);
     }
     const projectKey = await selectedProject(flags);
-    const result = await blocksRequest("/data/v4/Files/UploadFileToLocalStorage", {
+    const result = await blocksRequest("/data/v4/files/upload-file-to-local-storage", {
         body: form,
         impersonatedProjectAuth: true,
         ...requestContext(flags),

package/dist/commands/data/files/upload.d.ts

@@ -1,7 +1,5 @@
 /**
- * Composed upload: give it a local file, it runs the right sequence of API calls itself --
- * presign + PUT + DMS-register for cloud storage (--local-storage for the single-call
- * local-storage path) -- instead of you chaining presigned-upload-url/upload-to-url/dms-upload
- * (or upload-to-local-storage) by hand.
+ * Composed upload: create the file/version metadata and PUT cloud bytes, or use the
+ * one-call local-storage path. The upload is immediately part of the object tree.
  */
 export declare function dataFilesUpload(argv: string[]): Promise<void>;

package/dist/commands/data/files/upload.js

@@ -3,7 +3,7 @@ import { basename, extname } from "node:path";
 import { booleanFlag, optionalIntegerFlag, stringFlag } from "../../../lib/args.js";
 import { blocksRequest } from "../../../lib/api.js";
 import { confirmMutation } from "../../../lib/confirm.js";
-import { compact, listFlag } from "../../../lib/json-flag.js";
+import { compact } from "../../../lib/json-flag.js";
 import { writeOutput } from "../../../lib/output.js";
 import { requestContext } from "../../../lib/request-context.js";
 import { parseCommand, selectedProject } from "../../../lib/workspace.js";
@@ -25,10 +25,8 @@ const CONTENT_TYPES = {
     ".zip": "application/zip"
 };
 /**
- * Composed upload: give it a local file, it runs the right sequence of API calls itself --
- * presign + PUT + DMS-register for cloud storage (--local-storage for the single-call
- * local-storage path) -- instead of you chaining presigned-upload-url/upload-to-url/dms-upload
- * (or upload-to-local-storage) by hand.
+ * Composed upload: create the file/version metadata and PUT cloud bytes, or use the
+ * one-call local-storage path. The upload is immediately part of the object tree.
  */
 export async function dataFilesUpload(argv) {
     const { flags } = parseCommand(argv);
@@ -43,7 +41,7 @@ export async function dataFilesUpload(argv) {
 async function uploadToLocalStorage(filePath, name, flags) {
     const parentDirectoryId = stringFlag(flags, "parent-id") || stringFlag(flags, "parent-directory-id");
     if (booleanFlag(flags, "dry-run")) {
-        writeOutput({ dryRun: true, endpoint: "/data/v4/Files/UploadFileToLocalStorage", file: filePath, name }, flags);
+        writeOutput({ dryRun: true, endpoint: "/data/v4/files/upload-file-to-local-storage", file: filePath, name }, flags);
         return;
     }
     await confirmMutation(flags, `Upload '${filePath}' to local storage as '${name}'.`);
@@ -52,6 +50,9 @@ async function uploadToLocalStorage(filePath, name, flags) {
     form.set("Name", name);
     if (parentDirectoryId)
         form.set("ParentDirectoryId", parentDirectoryId);
+    const itemId = stringFlag(flags, "item-id");
+    if (itemId)
+        form.set("ItemId", itemId);
     const tags = stringFlag(flags, "tags");
     if (tags)
         form.set("Tags", tags);
@@ -62,7 +63,7 @@ async function uploadToLocalStorage(filePath, name, flags) {
     if (configurationName)
         form.set("ConfigurationName", configurationName);
     const projectKey = await selectedProject(flags);
-    const result = await blocksRequest("/data/v4/Files/UploadFileToLocalStorage", {
+    const result = await blocksRequest("/data/v4/files/upload-file-to-local-storage", {
         body: form,
         impersonatedProjectAuth: true,
         ...requestContext(flags),
@@ -77,6 +78,7 @@ async function uploadViaPresignedUrl(filePath, name, flags) {
     const presignBody = compact({
         accessModifier: stringFlag(flags, "access-modifier") || undefined,
         configurationName: stringFlag(flags, "configuration-name") || undefined,
+        itemId: stringFlag(flags, "item-id") || undefined,
         metaData: stringFlag(flags, "meta-data") || undefined,
         moduleName: optionalIntegerFlag(flags, "module-name"),
         name,
@@ -87,16 +89,15 @@ async function uploadViaPresignedUrl(filePath, name, flags) {
         writeOutput({
             dryRun: true,
             steps: [
-                { body: presignBody, endpoint: "/data/v4/Files/GetPreSignedUrlForUpload" },
-                { contentType, endpoint: "PUT <uploadUrl>", file: filePath },
-                { endpoint: "/data/v4/Files/UploadFile" }
+                { body: presignBody, endpoint: "/data/v4/files/get-pre-signed-url-for-upload" },
+                { contentType, endpoint: "PUT <uploadUrl>", file: filePath }
             ]
         }, flags);
         return;
     }
-    await confirmMutation(flags, `Upload '${filePath}' as '${name}' (presign + PUT + DMS register).`);
+    await confirmMutation(flags, `Upload '${filePath}' as '${name}' (create metadata + PUT bytes).`);
     const projectKey = await selectedProject(flags);
-    const presigned = await blocksRequest("/data/v4/Files/GetPreSignedUrlForUpload", {
+    const presigned = await blocksRequest("/data/v4/files/get-pre-signed-url-for-upload", {
         body: presignBody,
         impersonatedProjectAuth: true,
         ...requestContext(flags),
@@ -118,22 +119,7 @@ async function uploadViaPresignedUrl(filePath, name, flags) {
     if (!putResponse.ok) {
         throw new Error(`Upload PUT ${putResponse.status} ${putResponse.statusText}: ${await putResponse.text().catch(() => "")}`);
     }
-    const registered = await blocksRequest("/data/v4/Files/UploadFile", {
-        body: {
-            upload: [
-                compact({
-                    artifactName: name,
-                    fileStorageId: fileId,
-                    parentId: parentDirectoryId || undefined,
-                    tags: listFlag(flags, "tags")
-                })
-            ]
-        },
-        impersonatedProjectAuth: true,
-        ...requestContext(flags),
-        projectTenantId: projectKey
-    });
-    writeOutput({ fileId, registered, uploadUrl }, flags);
+    writeOutput({ fileId, uploadUrl, uploaded: true }, flags);
 }
 function firstString(record, keys) {
     for (const key of keys) {