@voobase/cli 0.1.1-nonprod.2039 → 0.1.1-nonprod.2050

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voobase/cli",
-  "version": "0.1.1-nonprod.2039",
+  "version": "0.1.1-nonprod.2050",
   "private": false,
   "platformDistributionProfile": {
     "name": "nonprod",
@@ -20,6 +20,9 @@
   "bin": {
     "platform": "dist-bundle/index.mjs"
   },
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "scripts": {
     "dev": "tsx watch src/index.ts --help",
     "build": "corepack pnpm --filter @platform/sdk build && corepack pnpm --filter @platform/capability-auth build && corepack pnpm --filter @platform/capability-cms build && corepack pnpm --filter @platform/capability-data-form build && tsc -p tsconfig.json",
@@ -53,10 +56,10 @@
   "bundleDependencies": [],
   "platformDistributionBuild": {
     "channel": "nonprod",
-    "version": "0.1.1-nonprod.2039",
-    "sequence": 2039,
-    "gitSha": "e5d1c1f",
-    "fullGitSha": "e5d1c1f21da6f231f3c7d42fe227ae44b4b16ca1",
-    "buildId": "0.1.1-nonprod.2039+e5d1c1f"
+    "version": "0.1.1-nonprod.2050",
+    "sequence": 2050,
+    "gitSha": "d865074",
+    "fullGitSha": "d865074bb73db991855af0e2f8f722e88db00655",
+    "buildId": "0.1.1-nonprod.2050+d865074"
   }
 }

package/runtime-sdk/dist/auth/client.d.ts

@@ -0,0 +1,14 @@
+import { BaseRuntimeSdk, type RuntimeSdkOptions } from "../http.js";
+import type { RuntimeEndUserAuthMe, RuntimeEndUserRoleRecord } from "../types/auth.js";
+export declare class RuntimeAuthClient extends BaseRuntimeSdk {
+    constructor(options: RuntimeSdkOptions);
+    getCurrentEndUser(): Promise<RuntimeEndUserAuthMe>;
+    getCurrentEndUserRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    isSignedIn(): Promise<boolean>;
+    getMe(): Promise<RuntimeEndUserAuthMe>;
+    listMyRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    signOut(): Promise<{
+        app_id: string;
+        signed_out: true;
+    }>;
+}

package/runtime-sdk/dist/auth/client.js

@@ -0,0 +1,28 @@
+import { BaseRuntimeSdk } from "../http.js";
+export class RuntimeAuthClient extends BaseRuntimeSdk {
+    constructor(options) {
+        super(options);
+    }
+    async getCurrentEndUser() {
+        return this.requestApp("/end-user-auth/me");
+    }
+    async getCurrentEndUserRoles() {
+        const result = await this.requestApp("/end-user-auth/roles");
+        return result.items;
+    }
+    async isSignedIn() {
+        const me = await this.getCurrentEndUser();
+        return me.access_state === "authenticated_and_ready";
+    }
+    async getMe() {
+        return this.getCurrentEndUser();
+    }
+    async listMyRoles() {
+        return this.getCurrentEndUserRoles();
+    }
+    async signOut() {
+        return this.requestApp("/end-user-auth/sign-out", {
+            method: "POST"
+        });
+    }
+}

package/runtime-sdk/dist/blob/client.d.ts

@@ -0,0 +1,39 @@
+import { BaseRuntimeSdk, type RuntimeSdkOptions } from "../http.js";
+import type { RuntimeBlobHydrateResponse, RuntimeBlobUploadSession, RuntimeCompleteBlobUploadInput, RuntimeCompleteBlobUploadResult, RuntimeCreateBlobUploadSessionInput, RuntimeHydrateBlobRefsInput, RuntimeHydrateRecordBlobsInput } from "../types/object-storage.js";
+export type RuntimeBlobBinaryBody = Blob | ArrayBuffer | ArrayBufferView;
+export declare class RuntimeBlobClient extends BaseRuntimeSdk {
+    private cachedUploadTicket;
+    constructor(options: RuntimeSdkOptions);
+    createUploadSession(input: RuntimeCreateBlobUploadSessionInput): Promise<RuntimeBlobUploadSession>;
+    uploadBinary(args: {
+        uploadUrl: string;
+        body: RuntimeBlobBinaryBody;
+        contentType: string;
+        headers?: Record<string, string>;
+    }): Promise<void>;
+    completeUpload(uploadSessionId: string, input?: RuntimeCompleteBlobUploadInput): Promise<RuntimeCompleteBlobUploadResult>;
+    upload(args: RuntimeCreateBlobUploadSessionInput & {
+        body: RuntimeBlobBinaryBody;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadFile(file: Blob & {
+        name?: string;
+    }, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filename?: string;
+        content_type?: string;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadFiles(files: Array<Blob & {
+        name?: string;
+    }>, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filenames?: string[];
+        content_types?: string[];
+        sha256_list?: Array<string | undefined>;
+    }): Promise<RuntimeCompleteBlobUploadResult[]>;
+    hydrateBlobRefs(args: RuntimeHydrateBlobRefsInput): Promise<RuntimeBlobHydrateResponse>;
+    hydrateRecordBlobs(args: RuntimeHydrateRecordBlobsInput): Promise<RuntimeBlobHydrateResponse>;
+    private createUploadTicket;
+    private withUploadTicket;
+    private clearUploadTicket;
+    private ensureUploadTicket;
+}

package/runtime-sdk/dist/blob/client.js

@@ -0,0 +1,148 @@
+import { BaseRuntimeSdk, RuntimeApiError } from "../http.js";
+const UPLOAD_TICKET_REFRESH_SKEW_MS = 30_000;
+const UPLOAD_TICKET_RETRYABLE_CODES = new Set(["missing_credentials", "ticket_invalid"]);
+export class RuntimeBlobClient extends BaseRuntimeSdk {
+    cachedUploadTicket = null;
+    constructor(options) {
+        super(options);
+    }
+    async createUploadSession(input) {
+        return this.withUploadTicket((ticket) => this.requestApp("/blobs/upload-sessions", {
+            method: "POST",
+            headers: {
+                Authorization: `Ticket ${ticket}`
+            },
+            body: JSON.stringify(input)
+        }));
+    }
+    async uploadBinary(args) {
+        await this.withUploadTicket(async (ticket) => {
+            const url = /^https?:\/\//i.test(args.uploadUrl)
+                ? new URL(args.uploadUrl)
+                : this.buildRequestUrl(args.uploadUrl);
+            const headers = new Headers(args.headers);
+            headers.set("Authorization", `Ticket ${ticket}`);
+            headers.set("Content-Type", args.contentType);
+            await this.requestVoidUrl(url, {
+                method: "PUT",
+                headers,
+                body: toRequestBody(args.body)
+            });
+        });
+    }
+    async completeUpload(uploadSessionId, input = {}) {
+        return this.withUploadTicket((ticket) => this.requestApp(`/blobs/upload-sessions/${encodeURIComponent(uploadSessionId)}/complete`, {
+            method: "POST",
+            headers: {
+                Authorization: `Ticket ${ticket}`
+            },
+            body: JSON.stringify(input)
+        }));
+    }
+    async upload(args) {
+        const { body, sha256, ...createInput } = args;
+        const session = await this.createUploadSession(createInput);
+        const contentType = args.content_type?.trim();
+        if (!contentType) {
+            throw new Error("content_type is required for runtime blob upload.");
+        }
+        await this.uploadBinary({
+            uploadUrl: session.upload_url,
+            body,
+            contentType,
+            headers: session.headers
+        });
+        return this.completeUpload(session.upload_session_id, {
+            ...(sha256 ? { sha256 } : {}),
+            ...(args.size_bytes !== undefined ? { size_bytes: args.size_bytes } : {})
+        });
+    }
+    async uploadFile(file, args = {}) {
+        const originalFilename = args.original_filename?.trim() || file.name?.trim() || "blob.bin";
+        const contentType = args.content_type?.trim() || file.type?.trim() || "application/octet-stream";
+        return this.upload({
+            ...args,
+            original_filename: originalFilename,
+            content_type: contentType,
+            size_bytes: Number.isFinite(file.size) ? file.size : undefined,
+            body: file
+        });
+    }
+    async uploadFiles(files, args = {}) {
+        const results = [];
+        for (const [index, file] of files.entries()) {
+            results.push(await this.uploadFile(file, {
+                ...args,
+                ...(args.original_filenames?.[index] ? { original_filename: args.original_filenames[index] } : {}),
+                ...(args.content_types?.[index] ? { content_type: args.content_types[index] } : {}),
+                ...(args.sha256_list?.[index] ? { sha256: args.sha256_list[index] } : {})
+            }));
+        }
+        return results;
+    }
+    async hydrateBlobRefs(args) {
+        return this.requestApp("/blobs/hydrate", {
+            method: "POST",
+            body: JSON.stringify({
+                items: args.items
+            })
+        });
+    }
+    async hydrateRecordBlobs(args) {
+        return this.requestApp("/blobs/hydrate", {
+            method: "POST",
+            body: JSON.stringify({
+                resource_key: args.resourceKey,
+                record_id: args.recordId
+            })
+        });
+    }
+    async createUploadTicket() {
+        return this.requestApp("/blobs/upload-ticket", {
+            method: "POST"
+        });
+    }
+    async withUploadTicket(runner) {
+        const ticket = await this.ensureUploadTicket();
+        try {
+            return await runner(ticket);
+        }
+        catch (error) {
+            if (!isUploadTicketRetryableError(error)) {
+                throw error;
+            }
+            this.clearUploadTicket();
+            return runner(await this.ensureUploadTicket());
+        }
+    }
+    clearUploadTicket() {
+        this.cachedUploadTicket = null;
+    }
+    async ensureUploadTicket() {
+        if (this.cachedUploadTicket && this.cachedUploadTicket.expiresAtMs - UPLOAD_TICKET_REFRESH_SKEW_MS > Date.now()) {
+            return this.cachedUploadTicket.value;
+        }
+        const next = await this.createUploadTicket();
+        const expiresAtMs = Date.parse(next.expires_at);
+        this.cachedUploadTicket = {
+            value: next.upload_ticket,
+            expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs : Date.now()
+        };
+        return next.upload_ticket;
+    }
+}
+function toRequestBody(body) {
+    if (body instanceof ArrayBuffer) {
+        return body;
+    }
+    if (ArrayBuffer.isView(body)) {
+        return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    }
+    return body;
+}
+function isUploadTicketRetryableError(error) {
+    return (error instanceof RuntimeApiError &&
+        error.status === 401 &&
+        typeof error.code === "string" &&
+        UPLOAD_TICKET_RETRYABLE_CODES.has(error.code));
+}

package/runtime-sdk/dist/blob/client.test.d.ts

@@ -0,0 +1 @@
+export {};