@seliseblocks/cli-os 0.1.3 → 0.1.5

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

@@ -0,0 +1,55 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { booleanFlag, stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { confirmMutation } from "../../../lib/confirm.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+/**
+ * The one-call alternative to presigned-upload-url + upload-to-url, for projects backed
+ * by local storage (not cloud object storage). Sends multipart/form-data with the file bytes.
+ */
+export async function dataFilesUploadToLocalStorage(argv) {
+    const { flags } = parseCommand(argv);
+    const filePath = stringFlag(flags, "file", { required: true });
+    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);
+        return;
+    }
+    await confirmMutation(flags, `Upload '${filePath}' to local storage as '${name}'.`);
+    const form = new FormData();
+    form.set("File", new Blob([await readFile(filePath)]), name);
+    form.set("Name", name);
+    form.set("ParentDirectoryId", stringFlag(flags, "parent-directory-id"));
+    const itemId = stringFlag(flags, "item-id");
+    if (itemId)
+        form.set("ItemId", itemId);
+    const metaData = stringFlag(flags, "meta-data");
+    if (metaData)
+        form.set("MetaData", metaData);
+    const tags = stringFlag(flags, "tags");
+    if (tags)
+        form.set("Tags", tags);
+    const accessModifier = stringFlag(flags, "access-modifier");
+    if (accessModifier)
+        form.set("AccessModifier", accessModifier);
+    const configurationName = stringFlag(flags, "configuration-name");
+    if (configurationName)
+        form.set("ConfigurationName", configurationName);
+    if (additionalPropertiesRaw) {
+        const parsed = JSON.parse(additionalPropertiesRaw);
+        for (const [key, value] of Object.entries(parsed))
+            form.set(`AdditionalProperties[${key}]`, value);
+    }
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/Files/UploadFileToLocalStorage", {
+        body: form,
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/files/upload-to-url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Step 2 of the cloud-storage upload path (after `data:files:presigned-upload-url`).
+ * This PUTs straight to the storage provider's pre-signed URL - no `x-blocks-key`, no
+ * bearer token, not a Blocks API call. Adds `x-ms-blob-type: BlockBlob` by default
+ * (Azure block-blob upload header); pass --blob-type to override or --no-blob-type-header
+ * to omit it entirely for non-Azure providers.
+ */
+export declare function dataFilesUploadToUrl(argv: string[]): Promise<void>;

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

@@ -0,0 +1,36 @@
+import { readFile } from "node:fs/promises";
+import { booleanFlag, stringFlag } from "../../../lib/args.js";
+import { confirmMutation } from "../../../lib/confirm.js";
+import { writeOutput } from "../../../lib/output.js";
+import { parseCommand } from "../../../lib/workspace.js";
+/**
+ * Step 2 of the cloud-storage upload path (after `data:files:presigned-upload-url`).
+ * This PUTs straight to the storage provider's pre-signed URL - no `x-blocks-key`, no
+ * bearer token, not a Blocks API call. Adds `x-ms-blob-type: BlockBlob` by default
+ * (Azure block-blob upload header); pass --blob-type to override or --no-blob-type-header
+ * to omit it entirely for non-Azure providers.
+ */
+export async function dataFilesUploadToUrl(argv) {
+    const { flags } = parseCommand(argv);
+    const url = stringFlag(flags, "url", { required: true });
+    const filePath = stringFlag(flags, "file", { required: true });
+    const contentType = stringFlag(flags, "content-type", { required: true });
+    const blobType = stringFlag(flags, "blob-type", { defaultValue: "BlockBlob" });
+    const skipBlobTypeHeader = flags["no-blob-type-header"] === true;
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, file: filePath, url }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Upload '${filePath}' to the pre-signed URL.`);
+    const body = await readFile(filePath);
+    const headers = { "Content-Type": contentType };
+    if (!skipBlobTypeHeader && blobType)
+        headers["x-ms-blob-type"] = blobType;
+    const response = await fetch(url, { body, headers, method: "PUT" }).catch((error) => {
+        throw new Error(`Upload PUT failed: ${error.message}`);
+    });
+    if (!response.ok) {
+        throw new Error(`Upload PUT ${response.status} ${response.statusText}: ${await response.text().catch(() => "")}`);
+    }
+    writeOutput({ ok: true, status: response.status }, flags);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export declare function dataFilesUpload(argv: string[]): Promise<void>;

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

@@ -0,0 +1,145 @@
+import { readFile } from "node:fs/promises";
+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 { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+const CONTENT_TYPES = {
+    ".csv": "text/csv",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".gif": "image/gif",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".json": "application/json",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain",
+    ".webp": "image/webp",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".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.
+ */
+export async function dataFilesUpload(argv) {
+    const { flags } = parseCommand(argv);
+    const filePath = stringFlag(flags, "file", { required: true });
+    const name = stringFlag(flags, "name") || basename(filePath);
+    if (booleanFlag(flags, "local-storage")) {
+        await uploadToLocalStorage(filePath, name, flags);
+        return;
+    }
+    await uploadViaPresignedUrl(filePath, name, flags);
+}
+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);
+        return;
+    }
+    await confirmMutation(flags, `Upload '${filePath}' to local storage as '${name}'.`);
+    const form = new FormData();
+    form.set("File", new Blob([await readFile(filePath)]), name);
+    form.set("Name", name);
+    if (parentDirectoryId)
+        form.set("ParentDirectoryId", parentDirectoryId);
+    const tags = stringFlag(flags, "tags");
+    if (tags)
+        form.set("Tags", tags);
+    const accessModifier = stringFlag(flags, "access-modifier");
+    if (accessModifier)
+        form.set("AccessModifier", accessModifier);
+    const configurationName = stringFlag(flags, "configuration-name");
+    if (configurationName)
+        form.set("ConfigurationName", configurationName);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/Files/UploadFileToLocalStorage", {
+        body: form,
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}
+async function uploadViaPresignedUrl(filePath, name, flags) {
+    const parentDirectoryId = stringFlag(flags, "parent-id") || stringFlag(flags, "parent-directory-id");
+    const contentType = stringFlag(flags, "content-type") || CONTENT_TYPES[extname(filePath).toLowerCase()] || "application/octet-stream";
+    const tags = stringFlag(flags, "tags");
+    const presignBody = compact({
+        accessModifier: stringFlag(flags, "access-modifier") || undefined,
+        configurationName: stringFlag(flags, "configuration-name") || undefined,
+        metaData: stringFlag(flags, "meta-data") || undefined,
+        moduleName: optionalIntegerFlag(flags, "module-name"),
+        name,
+        parentDirectoryId: parentDirectoryId || undefined,
+        tags: tags || undefined
+    });
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({
+            dryRun: true,
+            steps: [
+                { body: presignBody, endpoint: "/data/v4/Files/GetPreSignedUrlForUpload" },
+                { contentType, endpoint: "PUT <uploadUrl>", file: filePath },
+                { endpoint: "/data/v4/Files/UploadFile" }
+            ]
+        }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Upload '${filePath}' as '${name}' (presign + PUT + DMS register).`);
+    const projectKey = await selectedProject(flags);
+    const presigned = await blocksRequest("/data/v4/Files/GetPreSignedUrlForUpload", {
+        body: presignBody,
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    const uploadUrl = firstString(presigned, ["uploadUrl", "url", "preSignedUrl"]);
+    const fileId = firstString(presigned, ["fileId", "itemId", "fileStorageId"]);
+    if (!uploadUrl || !fileId) {
+        throw new Error(`Presigned URL response did not include a recognizable uploadUrl/fileId. Check the response and consider running the individual steps manually: ${JSON.stringify(presigned)}`);
+    }
+    const bytes = await readFile(filePath);
+    const putResponse = await fetch(uploadUrl, {
+        body: bytes,
+        headers: { "Content-Type": contentType, "x-ms-blob-type": "BlockBlob" },
+        method: "PUT"
+    }).catch((error) => {
+        throw new Error(`Upload PUT failed: ${error.message}`);
+    });
+    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);
+}
+function firstString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return undefined;
+}

package/dist/commands/data/rules/policy/delete.d.ts

@@ -0,0 +1 @@
+export declare function dataRulesPolicyDelete(argv: string[]): Promise<void>;

package/dist/commands/data/rules/policy/delete.js

@@ -0,0 +1,24 @@
+import { booleanFlag, stringFlag } from "../../../../lib/args.js";
+import { blocksRequest } from "../../../../lib/api.js";
+import { confirmMutation } from "../../../../lib/confirm.js";
+import { writeOutput } from "../../../../lib/output.js";
+import { requestContext } from "../../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../../lib/workspace.js";
+export async function dataRulesPolicyDelete(argv) {
+    const { args, flags } = parseCommand(argv);
+    const itemId = args[0] || stringFlag(flags, "item-id", { required: true });
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: "/data/v4/data-access/policy/delete", itemId }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Delete data-access policy '${itemId}'.`);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/data-access/policy/delete", {
+        impersonatedProjectAuth: true,
+        method: "DELETE",
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { itemId }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/rules/policy/get.d.ts

@@ -0,0 +1 @@
+export declare function dataRulesPolicyGet(argv: string[]): Promise<void>;

package/dist/commands/data/rules/policy/get.js

@@ -0,0 +1,17 @@
+import { stringFlag } from "../../../../lib/args.js";
+import { blocksRequest } from "../../../../lib/api.js";
+import { writeOutput } from "../../../../lib/output.js";
+import { requestContext } from "../../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../../lib/workspace.js";
+export async function dataRulesPolicyGet(argv) {
+    const { args, flags } = parseCommand(argv);
+    const schemaName = args[0] || stringFlag(flags, "schema-name", { required: true });
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/data-access/policy/get", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { schemaName }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/aggregation.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaAggregation(argv: string[]): Promise<void>;

package/dist/commands/data/schema/aggregation.js

@@ -0,0 +1,26 @@
+import { booleanFlag, integerFlag, optionalIntegerFlag, stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function dataSchemaAggregation(argv) {
+    const { flags } = parseCommand(argv);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/aggregation", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: {
+            CollectionName: stringFlag(flags, "collection-name") || undefined,
+            Keyword: stringFlag(flags, "keyword") || undefined,
+            PageNo: integerFlag(flags, "page", 1),
+            PageSize: integerFlag(flags, "page-size", 100),
+            ProjectKey: projectKey,
+            SchemaName: stringFlag(flags, "schema-name") || undefined,
+            SchemaType: optionalIntegerFlag(flags, "schema-type"),
+            SortBy: stringFlag(flags, "sort-by") || undefined,
+            SortDescending: booleanFlag(flags, "sort-desc") || undefined
+        }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/change-logs.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaChangeLogs(argv: string[]): Promise<void>;

package/dist/commands/data/schema/change-logs.js

@@ -0,0 +1,14 @@
+import { blocksRequest } from "../../../lib/api.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function dataSchemaChangeLogs(argv) {
+    const { flags } = parseCommand(argv);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/unadapted-change-logs", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/delete.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaDelete(argv: string[]): Promise<void>;

package/dist/commands/data/schema/delete.js

@@ -0,0 +1,24 @@
+import { booleanFlag, stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { confirmMutation } from "../../../lib/confirm.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function dataSchemaDelete(argv) {
+    const { args, flags } = parseCommand(argv);
+    const id = args[0] || stringFlag(flags, "id", { required: true });
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: "/data/v4/schemas", id }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Delete schema definition '${id}'. This cannot be undone.`);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas", {
+        impersonatedProjectAuth: true,
+        method: "DELETE",
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { id }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/fields.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `fields` (a FieldDefinitionRequest[]: name/type/isArray/isPIIData/isUniqueData/description) has no
+ * single-value flag equivalent - pass it via --body/--file. Convenience flags cover the scalar/array-of-string fields.
+ */
+export declare function dataSchemaFields(argv: string[]): Promise<void>;

package/dist/commands/data/schema/fields.js

@@ -0,0 +1,39 @@
+import { booleanFlag, 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";
+/**
+ * `fields` (a FieldDefinitionRequest[]: name/type/isArray/isPIIData/isUniqueData/description) has no
+ * single-value flag equivalent - pass it via --body/--file. Convenience flags cover the scalar/array-of-string fields.
+ */
+export async function dataSchemaFields(argv) {
+    const { flags } = parseCommand(argv);
+    const body = {
+        ...(await jsonBodyFlag(flags)),
+        ...compact({
+            deletableFieldNames: listFlag(flags, "deletable-fields"),
+            schemaDefinitionItemId: stringFlag(flags, "schema-id") || undefined
+        })
+    };
+    if (!body.schemaDefinitionItemId)
+        throw new Error("Provide --schema-id (the target schema's itemId).");
+    if (!Array.isArray(body.fields) && !Array.isArray(body.deletableFieldNames)) {
+        throw new Error("Provide --deletable-fields a,b and/or a 'fields' array via --body/--file.");
+    }
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: "/data/v4/schemas/fields", request: body }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Save field definitions for schema '${body.schemaDefinitionItemId}'.`);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/fields", {
+        body,
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/get-by-name.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaGetByName(argv: string[]): Promise<void>;

package/dist/commands/data/schema/get-by-name.js

@@ -0,0 +1,17 @@
+import { stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function dataSchemaGetByName(argv) {
+    const { args, flags } = parseCommand(argv);
+    const schemaName = args[0] || stringFlag(flags, "schema-name", { required: true });
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/info-by-name", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { schemaName }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/get.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaGet(argv: string[]): Promise<void>;

package/dist/commands/data/schema/get.js

@@ -0,0 +1,17 @@
+import { stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function dataSchemaGet(argv) {
+    const { args, flags } = parseCommand(argv);
+    const id = args[0] || stringFlag(flags, "id", { required: true });
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/get-by-id", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { id }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/info/list.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaInfoList(argv: string[]): Promise<void>;

package/dist/commands/data/schema/info/list.js

@@ -0,0 +1,15 @@
+import { blocksRequest } from "../../../../lib/api.js";
+import { writeOutput } from "../../../../lib/output.js";
+import { requestContext } from "../../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../../lib/workspace.js";
+export async function dataSchemaInfoList(argv) {
+    const { flags } = parseCommand(argv);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/info", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { projectKey }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/info/save.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaInfoSave(argv: string[]): Promise<void>;

package/dist/commands/data/schema/info/save.js

@@ -0,0 +1,34 @@
+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";
+import { parseCommand, selectedProject } from "../../../../lib/workspace.js";
+export async function dataSchemaInfoSave(argv) {
+    const { flags } = parseCommand(argv);
+    const body = {
+        ...(await jsonBodyFlag(flags)),
+        ...compact({
+            collectionName: stringFlag(flags, "collection-name") || undefined,
+            schemaName: stringFlag(flags, "schema-name") || undefined,
+            schemaType: optionalIntegerFlag(flags, "schema-type")
+        })
+    };
+    if (!body.schemaName)
+        throw new Error("Provide --schema-name (or set it in --body/--file).");
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: "/data/v4/schemas/info", request: body }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Create schema '${body.schemaName}' (metadata only - use 'data:schema:fields' to add fields).`);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/info", {
+        body,
+        impersonatedProjectAuth: true,
+        method: "POST",
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/schema/info/update.d.ts

@@ -0,0 +1 @@
+export declare function dataSchemaInfoUpdate(argv: string[]): Promise<void>;

package/dist/commands/data/schema/info/update.js

@@ -0,0 +1,35 @@
+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";
+import { parseCommand, selectedProject } from "../../../../lib/workspace.js";
+export async function dataSchemaInfoUpdate(argv) {
+    const { flags } = parseCommand(argv);
+    const body = {
+        ...(await jsonBodyFlag(flags)),
+        ...compact({
+            collectionName: stringFlag(flags, "collection-name") || undefined,
+            itemId: stringFlag(flags, "item-id") || undefined,
+            schemaName: stringFlag(flags, "schema-name") || undefined,
+            schemaType: optionalIntegerFlag(flags, "schema-type")
+        })
+    };
+    if (!body.itemId)
+        throw new Error("Provide --item-id (the existing schema's itemId).");
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: "/data/v4/schemas/info", request: body }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Update schema '${body.itemId}'.`);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/data/v4/schemas/info", {
+        body,
+        impersonatedProjectAuth: true,
+        method: "PUT",
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/data/sync.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Composed "deploy my data model" flow: validate local schemas/rules, push schemas, deploy
+ * rules, then reload the data gateway so the changes actually take effect. Nothing else in
+ * this CLI calls data:reload automatically -- pushed schema/rule changes can otherwise sit
+ * staged without going live.
+ */
+export declare function dataSync(argv: string[]): Promise<void>;

package/dist/commands/data/sync.js

@@ -0,0 +1,46 @@
+import { booleanFlag } from "../../lib/args.js";
+import { confirmMutation } from "../../lib/confirm.js";
+import { readRulesFile, readSchemaFiles, validateSchemas } from "../../lib/data-files.js";
+import { writeOutput } from "../../lib/output.js";
+import { parseCommand, selectedProject } from "../../lib/workspace.js";
+import { dataReload } from "./reload.js";
+import { dataRulesDeploy } from "./rules/deploy.js";
+import { dataSchemaPush } from "./schema/push.js";
+/**
+ * Composed "deploy my data model" flow: validate local schemas/rules, push schemas, deploy
+ * rules, then reload the data gateway so the changes actually take effect. Nothing else in
+ * this CLI calls data:reload automatically -- pushed schema/rule changes can otherwise sit
+ * staged without going live.
+ */
+export async function dataSync(argv) {
+    const { flags } = parseCommand(argv);
+    const dryRun = booleanFlag(flags, "dry-run");
+    const projectKey = await selectedProject(flags);
+    const schemas = await readSchemaFiles();
+    const errors = validateSchemas(schemas);
+    try {
+        await readRulesFile();
+    }
+    catch (error) {
+        if (!(dryRun && error.code === "ENOENT")) {
+            errors.push(`rules file: ${error.message}`);
+        }
+    }
+    if (errors.length)
+        throw new Error(`Data model validation failed:\n${errors.join("\n")}`);
+    if (dryRun) {
+        writeOutput({ dryRun: true, project: projectKey, schemas: schemas.length, steps: ["data:schema:push", "data:rules:deploy", "data:reload"] }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Sync data model for project '${projectKey}': push ${schemas.length} schema(s), deploy rules, then reload the gateway.`);
+    // Each step below prints its own output/confirmation-skip via --yes; this is 3 separate
+    // JSON blocks (one per step), not one combined document, since each step is a full
+    // existing command reused as-is rather than re-implemented to return a value.
+    const subArgv = [...argv.filter((token) => token !== "--dry-run"), "--yes"];
+    console.log("== data:schema:push ==");
+    await dataSchemaPush(subArgv);
+    console.log("== data:rules:deploy ==");
+    await dataRulesDeploy(subArgv);
+    console.log("== data:reload ==");
+    await dataReload(subArgv);
+}

package/dist/commands/data/validation/by-schema-field.d.ts

@@ -0,0 +1 @@
+export declare function dataValidationBySchemaField(argv: string[]): Promise<void>;