@calmlens/js-sdk 0.0.0 → 0.0.2

package/esm/Asset.js

@@ -1,10 +1,76 @@
 import * as zod from "zod/v4";
+import { metaStore } from "zod-meta";
 import { CLASSIFICATION_REPORT_SCHEMA } from "./Classification";
-import { createdAtField, primaryUuidField, saneStringField, updatedAtField, uuidField, } from "./SchemaUtils";
+import { docPropertyInfo } from "./DocMetaTypes";
+import { WORKFLOW_SCHEMA } from "./Workflow";
+import { createdAtField, primaryUuidField, saneStringField, updatedAtField, uuidField, } from "./ZodUtils";
 export const ASSET_STATUS_SCHEMA = zod.enum(["pending", "approved", "rejected", "error"]);
-export const ASSET_TYPE_SCHEMA = zod.enum(["image", "video", "audio", "document", "website"]);
+export const ASSET_TYPE_SCHEMA = zod.enum([
+    "image",
+    "video",
+    "audio",
+    "plaintext-document",
+    "multimedia-document",
+    "website",
+    "file",
+]);
+/**
+ * MIME types that are considered multimedia documents
+ * (documents that contain both text and embedded images/media)
+ */
+export const MULTIMEDIA_DOCUMENT_MIME_TYPES = [
+    "application/pdf",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document", // DOCX
+    "application/msword", // DOC
+    "application/rtf", // RTF
+    "application/vnd.oasis.opendocument.text", // ODT
+];
+/**
+ * Checks if a MIME type is a multimedia document
+ */
+export const isMultimediaDocumentMimeType = (mimeType) => {
+    return MULTIMEDIA_DOCUMENT_MIME_TYPES.includes(mimeType);
+};
 export const ASSET_VISIBILITY_SCHEMA = zod.enum(["public", "private"]);
-export const ASSET_SCHEMA = zod.object({
+export const CHECKSUMS_SCHEMA = zod.object({
+    md5: zod.string().nullish(),
+    sha1: zod.string().nullish(),
+    sha256: zod.string().nullish(),
+    sha384: zod.string().nullish(),
+    sha512: zod.string().nullish(),
+});
+export const IMAGE_DATA_SCHEMA = zod.object({
+    perceptualHash: zod.string().nullish(),
+});
+export const DOCUMENT_DATA_SCHEMA = zod.object({});
+export const PROCESSING_OPTIONS_SCHEMA = zod
+    .object({
+    keepAfterProcessing: zod
+        .boolean()
+        .nullish()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "Whether to keep the asset after processing",
+            defaultValue: false,
+        }),
+    ])),
+    image: zod
+        .object({
+        ocrEnabled: zod
+            .boolean()
+            .nullish()
+            .meta(metaStore([
+            docPropertyInfo({
+                description: "Whether to perform OCR on image assets or images extracted from multimedia documents and websites",
+                defaultValue: false,
+            }),
+        ])),
+    })
+        .nullish(),
+})
+    .nullish();
+export const ASSET_SCHEMA = zod
+    .object({
     id: primaryUuidField(),
     projectId: uuidField(),
     sizeInBytes: zod.number().nullish(),
@@ -12,25 +78,95 @@ export const ASSET_SCHEMA = zod.object({
     parentId: uuidField().nullish(),
     createdAt: createdAtField(),
     updatedAt: updatedAtField(),
+    checksums: CHECKSUMS_SCHEMA.nullish(),
+    imageData: IMAGE_DATA_SCHEMA.nullish(),
+    documentData: DOCUMENT_DATA_SCHEMA.nullish(),
     name: saneStringField({
         type: "large",
-    }),
+    }).meta(metaStore([
+        docPropertyInfo({
+            description: "Name of the asset",
+            placeholder: "my-image.jpg",
+        }),
+    ])),
     fileFormat: saneStringField().nullish(),
     fileExtension: saneStringField().nullish(),
     description: saneStringField({
         type: "large",
-    }).nullish(),
-    externalId: saneStringField().nullish(),
-    externalUrl: zod.string().url().nullish(),
+    })
+        .nullish()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "Optional description of the asset",
+            placeholder: "A beautiful landscape image",
+        }),
+    ])),
+    externalId: saneStringField()
+        .nullish()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "External identifier for the asset",
+            placeholder: "ext-12345",
+        }),
+    ])),
+    externalUrl: zod
+        .string()
+        .url()
+        .nullish()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "External URL associated with the asset",
+            placeholder: "https://example.com/asset",
+        }),
+    ])),
     previewImageId: saneStringField().nullish(),
     storageId: saneStringField().nullish(),
     averageColor: saneStringField().nullish(),
     type: ASSET_TYPE_SCHEMA,
     previewHash: saneStringField().nullish(),
-    metadata: zod.any().nullish(),
-    tags: zod.array(saneStringField()).nullish(),
+    metadata: zod
+        .any()
+        .nullish()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "Custom metadata for the asset",
+        }),
+    ])),
+    tags: zod
+        .array(saneStringField())
+        .nullish()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "Array of tags for the asset",
+            placeholder: '["tag1", "tag2"]',
+        }),
+    ])),
     report: CLASSIFICATION_REPORT_SCHEMA.nullish(),
     status: ASSET_STATUS_SCHEMA,
-    keepAfterProcessing: zod.boolean().nullish(),
-    visibility: ASSET_VISIBILITY_SCHEMA.nullish(),
-});
+    extractedTextId: saneStringField()
+        .nullish()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "ID of the extracted text content stored in R2 (e.g., from OCR or text extraction)",
+        }),
+    ])),
+    processingOptions: PROCESSING_OPTIONS_SCHEMA,
+    visibility: ASSET_VISIBILITY_SCHEMA.nullish().meta(metaStore([
+        docPropertyInfo({
+            description: "Visibility level of the asset",
+            defaultValue: "private",
+        }),
+    ])),
+    storageDeletedAt: zod.number().nullish(),
+    classificationWorkflow: WORKFLOW_SCHEMA.nullish().meta(metaStore([
+        docPropertyInfo({
+            description: "Workflow tracking the classification process for this asset",
+        }),
+    ])),
+})
+    .meta(metaStore([
+    docPropertyInfo({
+        description: "An asset in the system",
+        namedType: "Asset",
+    }),
+]));

package/esm/Auth.d.ts

@@ -0,0 +1,95 @@
+import type { ApiKey } from "./ApiKey";
+import type { Role } from "./Roles";
+import type { User } from "./User";
+export interface UserToken {
+    /**
+     * Always set to https://securetoken.google.com/GOOGLE_CLOUD_PROJECT
+     */
+    iss: string;
+    /**
+     * Always set to GOOGLE_CLOUD_PROJECT
+     */
+    aud: string;
+    /**
+     * The user's unique ID
+     */
+    sub: string;
+    /**
+     * The token issue time, in seconds since epoch
+     */
+    iat: number;
+    /**
+     * The token expiry time, normally 'iat' + 3600
+     */
+    exp: number;
+    /**
+     * The user's unique ID. Must be equal to 'sub'
+     */
+    user_id: string;
+    /**
+     * The time the user authenticated, normally 'iat'
+     */
+    auth_time: number;
+    /**
+     * The sign in provider, only set when the provider is 'anonymous'
+     */
+    provider_id?: "anonymous";
+    /**
+     * The user's primary email
+     */
+    email?: string;
+    /**
+     * The user's email verification status
+     */
+    email_verified?: boolean;
+    /**
+     * The user's primary phone number
+     */
+    phone_number?: string;
+    /**
+     * The user's display name
+     */
+    name?: string;
+    /**
+     * The user's profile photo URL
+     */
+    picture?: string;
+    /**
+     * Information on all identities linked to this user
+     */
+    firebase: any;
+    /**
+     * Custom claims set by the developer
+     */
+    [claim: string]: unknown;
+    /**
+     * @deprecated use `sub` instead
+     */
+    uid?: never;
+}
+export interface BaseAuth {
+    type: "apiKey" | "user";
+    roles: Role[];
+}
+export interface ApiKeyAuth extends BaseAuth {
+    type: "apiKey";
+    apiKey: ApiKey;
+    userId: string | undefined;
+    originalUserId: string | undefined;
+    getUser: () => Promise<User | undefined>;
+    getOriginalUser: () => Promise<User | undefined>;
+}
+export interface UserAuth extends BaseAuth {
+    type: "user";
+    token: Token;
+    idTokenExpiresAt: number;
+    provider: string;
+    userId: string;
+    originalUserId: string;
+    getUser: () => Promise<User>;
+    getOriginalUser: () => Promise<User>;
+}
+export type Auth = ApiKeyAuth | UserAuth;
+export interface Token extends UserToken {
+    roles: Role[];
+}

package/esm/Auth.js

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

package/esm/CalmLensClient.d.ts

@@ -1,4 +1,5 @@
 import type { Asset } from "./Asset";
+import type { GetAssetChildrenQuery, GetAssetChildrenResponse, GetAssetResponse, GetAssetsPageQuery, GetAssetsPageResponse } from "./PublicApiSchemas";
 import type { SubmitAssetOptions } from "./SharedTypes";
 import type { CalmLensClientOptions } from "./CalmLensTypes";
 export default class CalmLensClient {
@@ -27,15 +28,31 @@ export default class CalmLensClient {
      */
     static verifyWebhookSignature(payload: string | object, signatureHex: string, secret: string): Promise<boolean>;
     constructor(options: CalmLensClientOptions);
-    submitAsset(options: SubmitAssetOptions): Promise<Asset>;
-    getAsset(assetId: string): Promise<Asset>;
-    listAssets(options?: {
-        pageIndex?: number;
-        pageSize?: number;
-    }): Promise<{
-        items: Asset[];
-        total: number;
-        pageIndex: number;
-        pageSize: number;
-    }>;
+    get assets(): {
+        /**
+         * List all assets for a project
+         * @param options - Pagination and filtering options
+         * @returns Promise with paginated assets
+         */
+        list: (options: GetAssetsPageQuery) => Promise<GetAssetsPageResponse>;
+        /**
+         * Retrieve a specific asset by ID
+         * @param assetId - The asset ID
+         * @returns Promise with asset data
+         */
+        retrieve: (assetId: string) => Promise<GetAssetResponse>;
+        /**
+         * Get child assets of a parent asset
+         * @param assetId - The parent asset ID
+         * @param options - Pagination options
+         * @returns Promise with paginated child assets
+         */
+        listChildren: (assetId: string, options: GetAssetChildrenQuery) => Promise<GetAssetChildrenResponse>;
+        /**
+         * Submit a new asset for processing
+         * @param options - Asset submission options
+         * @returns Promise with created asset
+         */
+        create: (options: SubmitAssetOptions) => Promise<Asset>;
+    };
 }

package/esm/CalmLensClient.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Api } from "api-def";
+import { DOMAIN } from "./SharedConstants";
 import { verifyWebhookSignature } from "./CalmLensUtils";
 const createApi = (options) => {
     const api = new Api({
@@ -22,40 +23,56 @@ const createApi = (options) => {
                 },
             },
         ],
+        requestBackend: options.requestBackend,
     });
     return api;
 };
-// API endpoint definitions
+// API endpoint definitions using schemas like CalmLensApi.ts
 const createEndpoints = (api) => {
-    const postUploadAsset = api
+    const getAssetsPage = api
         .endpoint()
-        .bodyOf()
+        .queryOf()
         .paramsOf()
         .responseOf()
         .build({
-        id: "postUploadAsset",
-        method: "post",
-        path: "/projects/:projectId/assets",
+        id: "getAssetsPage",
+        method: "get",
+        path: "/projects/:projectId/assets/page",
     });
-    const getAsset = api.endpoint().paramsOf().responseOf().build({
+    const getAsset = api
+        .endpoint()
+        .paramsOf()
+        .responseOf()
+        .build({
         id: "getAsset",
         method: "get",
         path: "/projects/:projectId/assets/:assetId",
     });
-    const getAssetsPage = api
+    const getAssetChildren = api
         .endpoint()
-        .queryOf()
         .paramsOf()
+        .queryOf()
         .responseOf()
         .build({
-        id: "getAssetsPage",
+        id: "getAssetChildren",
         method: "get",
-        path: "/projects/:projectId/assets/page",
+        path: "/projects/:projectId/assets/:assetId/children",
+    });
+    const postUploadAsset = api
+        .endpoint()
+        .bodyOf()
+        .paramsOf()
+        .responseOf()
+        .build({
+        id: "postUploadAsset",
+        method: "post",
+        path: "/projects/:projectId/assets",
     });
     return {
-        postUploadAsset,
-        getAsset,
         getAssetsPage,
+        getAsset,
+        getAssetChildren,
+        postUploadAsset,
     };
 };
 export default class CalmLensClient {
@@ -93,50 +110,82 @@ export default class CalmLensClient {
         if (!options.projectId) {
             throw new Error("Project ID is required");
         }
-        this.options.baseUrl = (_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : "https://api.calmlens.com";
+        this.options.baseUrl = (_a = this.options.baseUrl) !== null && _a !== void 0 ? _a : `https://api.${DOMAIN}/v1`;
         this.api = createApi(this.options);
         this.endpoints = createEndpoints(this.api);
     }
-    submitAsset(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!("file" in options) && !("url" in options)) {
-                throw new Error("Either file content or URL is required");
-            }
-            if (!options.name) {
-                throw new Error("Asset name is required");
-            }
-            const result = yield this.endpoints.postUploadAsset.submit({
-                body: options,
-                params: {
-                    projectId: this.options.projectId,
-                },
-            });
-            return result.data;
-        });
-    }
-    getAsset(assetId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!assetId) {
-                throw new Error("Asset ID is required");
-            }
-            const result = yield this.endpoints.getAsset.submit({
-                params: {
-                    projectId: this.options.projectId,
-                    assetId,
-                },
-            });
-            return result.data;
-        });
-    }
-    listAssets() {
-        return __awaiter(this, arguments, void 0, function* (options = {}) {
-            const result = yield this.endpoints.getAssetsPage.submit({
-                params: {
-                    projectId: this.options.projectId,
-                },
-                query: options,
-            });
-            return result.data;
-        });
+    get assets() {
+        return {
+            /**
+             * List all assets for a project
+             * @param options - Pagination and filtering options
+             * @returns Promise with paginated assets
+             */
+            list: (options) => __awaiter(this, void 0, void 0, function* () {
+                const result = yield this.endpoints.getAssetsPage.submit({
+                    params: {
+                        projectId: this.options.projectId,
+                    },
+                    query: options,
+                });
+                return result.data;
+            }),
+            /**
+             * Retrieve a specific asset by ID
+             * @param assetId - The asset ID
+             * @returns Promise with asset data
+             */
+            retrieve: (assetId) => __awaiter(this, void 0, void 0, function* () {
+                if (!assetId) {
+                    throw new Error("Asset ID is required");
+                }
+                const result = yield this.endpoints.getAsset.submit({
+                    params: {
+                        projectId: this.options.projectId,
+                        assetId,
+                    },
+                });
+                return result.data;
+            }),
+            /**
+             * Get child assets of a parent asset
+             * @param assetId - The parent asset ID
+             * @param options - Pagination options
+             * @returns Promise with paginated child assets
+             */
+            listChildren: (assetId, options) => __awaiter(this, void 0, void 0, function* () {
+                if (!assetId) {
+                    throw new Error("Asset ID is required");
+                }
+                const result = yield this.endpoints.getAssetChildren.submit({
+                    params: {
+                        projectId: this.options.projectId,
+                        assetId,
+                    },
+                    query: options,
+                });
+                return result.data;
+            }),
+            /**
+             * Submit a new asset for processing
+             * @param options - Asset submission options
+             * @returns Promise with created asset
+             */
+            create: (options) => __awaiter(this, void 0, void 0, function* () {
+                if (!("file" in options) && !("url" in options)) {
+                    throw new Error("Either file content or URL is required");
+                }
+                if (!options.name) {
+                    throw new Error("Asset name is required");
+                }
+                const result = yield this.endpoints.postUploadAsset.submit({
+                    body: options,
+                    params: {
+                        projectId: this.options.projectId,
+                    },
+                });
+                return result.data;
+            }),
+        };
     }
 }

package/esm/CalmLensTypes.d.ts

@@ -1,5 +1,7 @@
+import type { RequestBackend } from "api-def";
 export interface CalmLensClientOptions {
     apiKey: string;
     projectId: string;
     baseUrl?: string;
+    requestBackend?: RequestBackend;
 }

package/esm/Classification.js

@@ -1,5 +1,5 @@
 import * as zod from "zod/v4";
-import { saneStringField } from "./SchemaUtils";
+import { saneStringField } from "./ZodUtils";
 // OpenAI Content Moderation Categories (Merged subcategories)
 export const CLASSIFICATION_CATEGORIES = [
     "sexual",

package/esm/DocMetaTypes.d.ts

@@ -0,0 +1,7 @@
+export declare const docPropertyInfo: import("zod-meta").ZodMetaFactory<{
+    description: string;
+    defaultValue?: string | number | boolean;
+    placeholder?: string;
+    namedType?: string;
+    example?: any;
+}>;

package/esm/DocMetaTypes.js

@@ -0,0 +1,4 @@
+import { createMetaType } from "zod-meta";
+export const docPropertyInfo = createMetaType({
+    id: "docPropertyInfo",
+});

package/esm/Page.d.ts

@@ -0,0 +1,42 @@
+import * as zod from "zod/v4";
+export declare const DEFAULT_PAGE_SIZE = 10;
+export declare const ORDER_SCHEMA: zod.ZodObject<{
+    field: zod.ZodString;
+    direction: zod.ZodEnum<{
+        ASC: "ASC";
+        DESC: "DESC";
+    }>;
+}, zod.z.core.$strip>;
+export type Order = zod.infer<typeof ORDER_SCHEMA>;
+export declare const PAGE_QUERY_SCHEMA: zod.ZodObject<{
+    pageIndex: zod.ZodDefault<zod.ZodNumber>;
+    pageSize: zod.ZodOptional<zod.ZodNumber>;
+    ordering: zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+        field: zod.ZodString;
+        direction: zod.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>;
+    }, zod.z.core.$strip>>>;
+}, zod.z.core.$strip>;
+export type PageQuery = zod.infer<typeof PAGE_QUERY_SCHEMA>;
+export interface Page<T> extends Required<PageQuery> {
+    items: T[];
+    total: number;
+    hasMore: boolean;
+}
+export declare const createPageSchema: <T extends zod.ZodType>(itemSchema: T) => zod.ZodIntersection<zod.ZodObject<{
+    pageIndex: zod.ZodNonOptional<zod.ZodDefault<zod.ZodNumber>>;
+    pageSize: zod.ZodNonOptional<zod.ZodOptional<zod.ZodNumber>>;
+    ordering: zod.ZodNonOptional<zod.ZodOptional<zod.ZodArray<zod.ZodObject<{
+        field: zod.ZodString;
+        direction: zod.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>;
+    }, zod.z.core.$strip>>>>;
+}, zod.z.core.$strip>, zod.ZodObject<{
+    items: zod.ZodArray<T>;
+    total: zod.ZodNumber;
+    hasMore: zod.ZodBoolean;
+}, zod.z.core.$strip>>;

package/esm/Page.js

@@ -0,0 +1,55 @@
+import * as zod from "zod/v4";
+import { metaStore } from "zod-meta";
+import { docPropertyInfo } from "./DocMetaTypes";
+export const DEFAULT_PAGE_SIZE = 10;
+export const ORDER_SCHEMA = zod.object({
+    field: zod.string().meta(metaStore([
+        docPropertyInfo({
+            description: "The field name to order by",
+            placeholder: "createdAt",
+        }),
+    ])),
+    direction: zod.enum(["ASC", "DESC"]).meta(metaStore([
+        docPropertyInfo({
+            description: "The sort direction",
+            defaultValue: "ASC",
+        }),
+    ])),
+});
+export const PAGE_QUERY_SCHEMA = zod.object({
+    pageIndex: zod
+        .number()
+        .min(0)
+        .default(0)
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "The zero-based page index",
+            defaultValue: "0",
+        }),
+    ])),
+    pageSize: zod
+        .number()
+        .min(1)
+        .max(100)
+        .optional()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "Number of items per page (1-100)",
+            placeholder: "10",
+        }),
+    ])),
+    ordering: zod
+        .array(ORDER_SCHEMA)
+        .optional()
+        .meta(metaStore([
+        docPropertyInfo({
+            description: "Array of field ordering specifications",
+            placeholder: '[{"field": "createdAt", "direction": "DESC"}]',
+        }),
+    ])),
+});
+export const createPageSchema = (itemSchema) => PAGE_QUERY_SCHEMA.required().and(zod.object({
+    items: zod.array(itemSchema),
+    total: zod.number(),
+    hasMore: zod.boolean(),
+}));