@hautechai/sdk 1.0.3 → 1.0.5

package/dist/sdk/pipelines/index.js

@@ -0,0 +1,208 @@
+import { Pipeline } from '@hautechai/pipelines';
+import { CallApi, PipelinesApi, } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+import { transformToListResponse } from '../transformers';
+const pipelines = (options) => {
+    const api = useAutogeneratedAPI({ API: PipelinesApi, options });
+    const callAPI = useAutogeneratedAPI({ API: CallApi, options });
+    const callMethod = (method) => 
+    // Type intersection is used as a type check assistance to prevent accidental passing of raw TaskOutput.
+    (params) => callAPI.call({
+        run: (methods) => method(methods)(params),
+    });
+    const createPipeline = () => new Pipeline({
+        access: {
+            attach: callMethod((methods) => methods.callControllerCallAccessAttachV1),
+            grant: callMethod((methods) => methods.callControllerCallAccessGrantV1),
+        },
+        accounts: {
+            create: callMethod((methods) => methods.callControllerCallAccountsCreateV1),
+            get: callMethod((methods) => methods.callControllerCallAccountsGetV1),
+            list: callMethod((methods) => methods.callControllerCallAccountsListV1),
+        },
+        balances: {
+            add: callMethod((methods) => methods.callControllerCallAccountsBalanceAddV1),
+            get: callMethod((methods) => methods.callControllerCallAccountsBalanceGetV1),
+            getSelf: callMethod((methods) => methods.callControllerCallAccountsBalanceSelfV1),
+        },
+        collections: {
+            create: callMethod((methods) => methods.callControllerCallCollectionsCreateV1),
+            items: {
+                add: callMethod((methods) => methods.callControllerCallCollectionsItemsAddV1),
+                list: callMethod((methods) => methods.callControllerCallCollectionsItemsListV1),
+                remove: callMethod((methods) => methods.callControllerCallCollectionsItemsRemoveV1),
+            },
+            get: callMethod((methods) => methods.callControllerCallCollectionsGetV1),
+            list: callMethod((methods) => methods.callControllerCallCollectionsListV1),
+            updateMetadata: callMethod((methods) => methods.callControllerCallCollectionsMetadataUpdateV1),
+        },
+        groups: {
+            accounts: {
+                add: callMethod((methods) => methods.callControllerCallGroupsAccountsAddV1),
+                remove: callMethod((methods) => methods.callControllerCallGroupsAccountsRemoveV1),
+            },
+            create: callMethod((methods) => methods.callControllerCallGroupsCreateV1),
+            delete: callMethod((methods) => methods.callControllerCallGroupsDeleteV1),
+            get: callMethod((methods) => methods.callControllerCallGroupsGetV1),
+        },
+        images: {
+            get: callMethod((methods) => methods.callControllerCallImagesGetV1),
+            getUrls: callMethod((methods) => methods.callControllerCallImagesGetManyV1),
+        },
+        videos: {
+            get: callMethod((methods) => methods.callControllerCallVideosGetV1),
+            getUrls: callMethod((methods) => methods.callControllerCallVideosGetManyV1),
+        },
+        operations: {
+            get: callMethod((methods) => methods.callControllerCallOperationsGetV1),
+            list: callMethod((methods) => methods.callControllerCallOperationsListV1),
+            updateMetadata: callMethod((methods) => methods.callControllerCallOperationsMetadataUpdateV1),
+            run: {
+                animate: {
+                    kling_1_6_pro: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunAnimateKling16ProV1V1),
+                    },
+                    kling_2_1: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunAnimateKling21V1V1),
+                    },
+                },
+                edit: {
+                    flux_kontext_dev: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunEditFluxKontextDevV1V1),
+                    },
+                },
+                haute: {
+                    linda: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunHauteLindaV1V1),
+                    },
+                    naomi: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunHauteNaomiV1V1),
+                    },
+                },
+                inpaint: {
+                    kate: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunInpaintKateV1V1),
+                    },
+                },
+                gpt: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunGptV1V1),
+                    v2: callMethod((methods) => methods.callControllerCallOperationsRunGptV2V1),
+                },
+                math: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunMathV1V1),
+                },
+                translate: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunTranslateV1V1),
+                },
+                imagine: {
+                    kate: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunImagineKateV1V1),
+                    },
+                },
+                upscale: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunUpscaleV1V1),
+                },
+                objectDetection: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunObjectDetectionV1V1),
+                },
+                segmentAnything: {
+                    embeddings: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunSegmentAnythingEmbeddingsV1V1),
+                    },
+                    mask: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunSegmentAnythingMaskV1V1),
+                    },
+                },
+                poseEstimation: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunPoseEstimationV1V1),
+                },
+                cut: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunCutV1V1),
+                },
+                crop: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunCropV1V1),
+                },
+                noise: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunNoiseV1V1),
+                },
+                contrast: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunContrastV1V1),
+                },
+                composite: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunCompositeV1V1),
+                },
+                vton: {
+                    gisele: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunVtonGiseleV1V1),
+                    },
+                },
+                negateImage: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunNegateImageV1V1),
+                },
+                resize: {
+                    v1: callMethod((methods) => methods.callControllerCallOperationsRunResizeV1V1),
+                },
+                strings: {
+                    template: {
+                        v1: callMethod((methods) => methods.callControllerCallOperationsRunStringsTemplateV1V1),
+                    },
+                },
+            },
+            wait: callMethod((methods) => methods.callControllerCallOperationsWaitV1),
+        },
+        poses: {
+            get: callMethod((methods) => methods.callControllerCallPosesGetV1),
+            list: callMethod((methods) => methods.callControllerCallPosesListV1),
+        },
+        stacks: {
+            create: callMethod((methods) => methods.callControllerCallStacksCreateV1),
+            get: callMethod((methods) => methods.callControllerCallStacksGetV1),
+            list: callMethod((methods) => methods.callControllerCallStacksListV1),
+            updateMetadata: callMethod((methods) => methods.callControllerCallStacksMetadataUpdateV1),
+            items: {
+                add: callMethod((methods) => methods.callControllerCallStacksItemsAddV1),
+                remove: callMethod((methods) => methods.callControllerCallStacksItemsRemoveV1),
+            },
+        },
+        storage: {
+            create: callMethod((methods) => methods.callControllerCallStorageCreateV1),
+            delete: callMethod((methods) => methods.callControllerCallStorageDeleteV1),
+            getMany: callMethod((methods) => methods.callControllerCallStorageGetManyV1),
+            update: callMethod((methods) => methods.callControllerCallStorageUpdateV1),
+        },
+    });
+    return {
+        constructTemplate: (consructPipeline) => consructPipeline(createPipeline()),
+        create: async (props) => api.call({
+            run: (methods) => methods.pipelinesControllerCreatePipelineV1({
+                metadata: props.metadata,
+                tasks: (props.template?.tasks ?? props.tasks),
+                state: props.state,
+            }),
+        }),
+        get: async (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.pipelinesControllerGetPipelineV1(props.id),
+        }),
+        list: (props = {}) => api.call({
+            run: (methods) => methods.pipelinesControllerListPipelinesV1(props.orderBy, props.limit, props.cursor),
+            transform: transformToListResponse,
+        }),
+        wait: async (props) => new Promise((resolve, reject) => {
+            const initialDelay = 5000;
+            const delay = 2000;
+            let timeoutId;
+            const poll = async () => {
+                const pipeline = (await api.call({
+                    run: (methods) => methods.pipelinesControllerGetPipelineV1(props.id),
+                }));
+                if (pipeline.status === 'completed')
+                    return resolve(pipeline);
+                if (pipeline.status === 'failed')
+                    return resolve(pipeline);
+                timeoutId = setTimeout(poll, delay);
+            };
+            timeoutId = setTimeout(poll, initialDelay);
+        }),
+    };
+};
+export default pipelines;

package/dist/sdk/pipelines/pipelines.js

@@ -0,0 +1 @@
+"use strict";

package/dist/sdk/poses/index.d.ts

@@ -0,0 +1,20 @@
+import { ListPosesParamsDto, PoseEntity } from '../../autogenerated';
+import { ListResponse, SDKOptions } from '../../types';
+import { PoseMetadata } from '../index';
+import { AddMetadata } from '../utils';
+type PoseEntityWithMetadata = AddMetadata<PoseEntity, PoseMetadata>;
+declare const poses: (options: SDKOptions) => {
+    putPreview: (props: {
+        id: string;
+        previewImageId: string;
+    }) => Promise<void>;
+    get: (props: {
+        id: string;
+    }) => Promise<PoseEntityWithMetadata | undefined>;
+    list: (props: ListPosesParamsDto) => Promise<ListResponse<PoseEntityWithMetadata>>;
+    updateMetadata: (props: {
+        id: string;
+        metadata?: PoseMetadata;
+    }) => Promise<void>;
+};
+export default poses;

package/dist/sdk/poses/index.js

@@ -0,0 +1,24 @@
+import { PosesApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+import { transformToListResponse } from '../transformers';
+const poses = (options) => {
+    const api = useAutogeneratedAPI({ API: PosesApi, options });
+    return {
+        putPreview: async (props) => api.call({
+            run: (methods) => methods.posesControllerSetPosePreviewV1(props.id, {
+                previewImageId: props.previewImageId,
+            }),
+        }),
+        get: async (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.posesControllerGetPoseV1(props.id),
+        }),
+        list: async (props) => api.call({
+            run: (methods) => methods.posesControllerListPosesV1(props.orderBy, props.limit, props.cursor),
+            transform: transformToListResponse,
+        }),
+        updateMetadata: async (props) => api.call({
+            run: (methods) => methods.posesControllerUpdateMetadataV1(props.id, { overwrite: props.metadata ?? {} }),
+        }),
+    };
+};
+export default poses;

package/dist/sdk/stacks/index.d.ts

@@ -0,0 +1,29 @@
+import { SDKOptions, ListProps, ListResponse } from '../../types';
+import { StackEntity } from '../../autogenerated';
+import { StackMetadata } from '../index';
+import { AddMetadata } from '../utils';
+type StackEntityWithMetadata = AddMetadata<StackEntity, StackMetadata>;
+declare const stacks: (options: SDKOptions) => {
+    create: (props?: {
+        metadata?: StackMetadata;
+    }) => Promise<StackEntity>;
+    get: (props: {
+        id: string;
+    }) => Promise<StackEntityWithMetadata | undefined>;
+    list: (props?: ListProps) => Promise<ListResponse<StackEntityWithMetadata>>;
+    items: {
+        add: (props: {
+            itemIds: string[];
+            stackId: string;
+        }) => Promise<void>;
+        remove: (props: {
+            itemIds: string[];
+            stackId: string;
+        }) => Promise<void>;
+    };
+    updateMetadata: (props: {
+        id: string;
+        metadata?: StackMetadata;
+    }) => Promise<void>;
+};
+export default stacks;

package/dist/sdk/stacks/index.js

@@ -0,0 +1,32 @@
+import { StacksApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+import { transformToListResponse } from '../transformers';
+const stacks = (options) => {
+    const api = useAutogeneratedAPI({ API: StacksApi, options });
+    return {
+        create: async (props = {}) => api.call({
+            run: (methods) => methods.stacksControllerCreateStackV1({
+                metadata: props.metadata,
+            }),
+        }),
+        get: async (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.stacksControllerGetStackV1(props.id),
+        }),
+        list: async (props = {}) => api.call({
+            run: (methods) => methods.stacksControllerListStacksV1(props.orderBy, props.limit, props.cursor),
+            transform: transformToListResponse,
+        }),
+        items: {
+            add: async (props) => api.call({
+                run: (methods) => methods.stacksControllerAddItemsV1(props.stackId, { itemIds: props.itemIds }),
+            }),
+            remove: async (props) => api.call({
+                run: (methods) => methods.stacksControllerRemoveItemsV1(props.stackId, { itemIds: props.itemIds }),
+            }),
+        },
+        updateMetadata: async (props) => api.call({
+            run: (methods) => methods.stacksControllerUpdateMetadataV1(props.id, { overwrite: props.metadata ?? {} }),
+        }),
+    };
+};
+export default stacks;

package/dist/sdk/storage/index.d.ts

@@ -0,0 +1,18 @@
+import { SDKOptions } from '../../types';
+declare const storage: (options: SDKOptions) => {
+    create: (props: {
+        key: string;
+        value: any;
+    }) => Promise<any>;
+    delete: (props: {
+        key: string;
+    }) => Promise<void>;
+    getMany: (props: {
+        keys: string[];
+    }) => Promise<Record<string, any>>;
+    update: (props: {
+        key: string;
+        value: any;
+    }) => Promise<any>;
+};
+export default storage;

package/dist/sdk/storage/index.js

@@ -0,0 +1,27 @@
+import { StorageApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const storage = (options) => {
+    const api = useAutogeneratedAPI({ API: StorageApi, options });
+    return {
+        create: async (props) => api.call({
+            run: (methods) => methods.storageControllerCreateRecordV1({
+                key: props.key,
+                value: props.value,
+            }),
+        }),
+        delete: async (props) => api.call({
+            run: (methods) => methods.storageControllerDeleteRecordV1({ key: props.key }),
+        }),
+        getMany: async (props) => api.call({
+            run: (methods) => methods.storageControllerGetRecordsV1({ keys: props.keys }),
+            transform: (response) => response.reduce((acc, item) => {
+                acc[item.key] = item.value;
+                return acc;
+            }, {}),
+        }),
+        update: async (props) => api.call({
+            run: (methods) => methods.storageControllerUpdateRecordV1({ key: props.key, value: props.value }),
+        }),
+    };
+};
+export default storage;

package/dist/sdk/transformers.d.ts

@@ -0,0 +1,7 @@
+import { ListResponse } from '../types';
+export declare const transformToListResponse: <T>(response: {
+    data: T[];
+    pageInfo: {
+        nextCursor?: string;
+    };
+}) => ListResponse<T>;

package/dist/sdk/transformers.js

@@ -0,0 +1,6 @@
+import { ListResponse } from '../types';
+export const transformToListResponse = (response) => {
+    const array = new ListResponse(...response.data);
+    array.nextCursor = response.pageInfo.nextCursor;
+    return array;
+};

package/dist/sdk/utils/index.d.ts

@@ -0,0 +1,10 @@
+import { SDKOptions } from '../../types';
+declare const utils: (options: SDKOptions) => {
+    seed: () => number;
+};
+export type AddMetadata<T extends {
+    metadata: unknown;
+}, M> = Omit<T, 'metadata'> & {
+    metadata: M;
+};
+export default utils;

package/dist/sdk/utils/index.js

@@ -0,0 +1,6 @@
+const utils = (options) => {
+    return {
+        seed: () => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER),
+    };
+};
+export default utils;

package/dist/sdk/videos/index.d.ts

@@ -0,0 +1,11 @@
+import { VideoEntity } from '../../autogenerated';
+import { SDKOptions } from '../../types';
+declare const videos: (options: SDKOptions) => {
+    get: (props: {
+        id: string;
+    }) => Promise<VideoEntity | undefined>;
+    getUrls: (props: {
+        ids: string[];
+    }) => Promise<Record<string, string>>;
+};
+export default videos;

package/dist/sdk/videos/index.js

@@ -0,0 +1,15 @@
+import { VideosApi } from '../../autogenerated';
+import { useAutogeneratedAPI } from '../api';
+const videos = (options) => {
+    const api = useAutogeneratedAPI({ API: VideosApi, options });
+    return {
+        get: async (props) => api.callWithReturningUndefinedOn404({
+            run: (methods) => methods.videosControllerGetVideoV1(props.id),
+        }),
+        getUrls: async (props) => api.call({
+            run: (methods) => methods.videosControllerGetUrlsV1({ ids: props.ids }),
+            transform: (data) => data.reduce((acc, { id, url }) => ({ ...acc, [id]: url }), {}),
+        }),
+    };
+};
+export default videos;

package/dist/token/index.d.ts

@@ -0,0 +1,15 @@
+import { MethodsPermissions } from '../autogenerated/permissions';
+export declare const createTokenSigner: (options: {
+    appId: string;
+    appKeyId: string;
+    appKeySecret: string;
+}) => {
+    createAccountToken: (props: {
+        accountId: string;
+        expiresInSeconds: number;
+        permissions?: Partial<MethodsPermissions>;
+    }) => Promise<string>;
+    createRootToken: (props: {
+        expiresInSeconds: number;
+    }) => Promise<string>;
+};

package/dist/token/index.js

@@ -0,0 +1,65 @@
+import * as jose from 'jose';
+const createPrivateKey = (key) => {
+    const header = `-----BEGIN PRIVATE KEY-----\n`;
+    const footer = `\n-----END PRIVATE KEY-----`;
+    // @ts-ignore
+    const keyBody = key.match(/.{1,64}/g).join('\n');
+    return header + keyBody + footer;
+};
+const createToken = async (props) => {
+    const alg = 'RS256';
+    const pkcs8 = createPrivateKey(props.appKeySecret);
+    const privateKey = await jose.importPKCS8(pkcs8, alg);
+    return await new jose.SignJWT(props.payload)
+        .setIssuedAt()
+        .setExpirationTime(`${props.expiresInSeconds}s`)
+        .setProtectedHeader({ alg, kid: props.appKeyId })
+        .sign(privateKey);
+};
+const serializePermissions = (permissions) => {
+    const result = [];
+    const traverse = (obj, path = []) => {
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'boolean' && value === true) {
+                result.push(path.concat(key).join(':'));
+            }
+            else if (typeof value === 'object') {
+                traverse(value, path.concat(key));
+            }
+        }
+    };
+    traverse(permissions);
+    return result;
+};
+export const createTokenSigner = (options) => {
+    if (!options.appId || options.appId.length === 0) {
+        throw new Error('appId is required');
+    }
+    if (!options.appKeyId || options.appKeyId.length === 0) {
+        throw new Error('appKeyId is required');
+    }
+    if (!options.appKeySecret || options.appKeySecret.length === 0) {
+        throw new Error('appKeySecret is required');
+    }
+    return {
+        createAccountToken: async (props) => createToken({
+            appKeyId: options.appKeyId,
+            appKeySecret: options.appKeySecret,
+            expiresInSeconds: props.expiresInSeconds,
+            payload: {
+                iss: options.appId,
+                permissions: serializePermissions(props.permissions ?? {}),
+                sub: props.accountId,
+            },
+        }),
+        createRootToken: async (props) => createToken({
+            appKeyId: options.appKeyId,
+            appKeySecret: options.appKeySecret,
+            expiresInSeconds: props.expiresInSeconds ?? 3600,
+            payload: {
+                iss: options.appId,
+                permissions: ['*'],
+            },
+        }),
+    };
+};

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+export interface SDKOptions {
+    authToken: () => string | Promise<string>;
+    endpoint?: string;
+    useWebsocket?: boolean;
+    allowPollingFallback?: boolean;
+}
+export type ListProps = {
+    cursor?: string;
+    limit?: number;
+    orderBy?: 'createdAt_ASC' | 'createdAt_DESC' | 'updatedAt_ASC' | 'updatedAt_DESC';
+};
+export declare class ListResponse<T> extends Array<T> {
+    nextCursor?: string;
+}
+export { AccountEntity, CollectionEntity, GroupEntity, ImageEntity, OperationEntity, PipelineDto, PipelinePreviewDto, ResourceEntity, StackEntity, StorageEntity, } from './autogenerated/api';

package/dist/types.js

@@ -0,0 +1,5 @@
+export class ListResponse extends Array {
+}
+// ------------------------------------------------------------
+// AUTOGENERATED TYPES END
+// ------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hautechai/sdk",
-    "version": "1.0.3",
+    "version": "1.0.5",
     "license": "MIT",
     "keywords": [],
     "repository": {

package/scripts/up-versions.sh

@@ -1,3 +1,6 @@
 #!/bin/bash
 
-pnpm semantic-release -t "${TAG_PREFIX}/${APP_NAME}@\${version}" --no-ci
+# Extract package name from package.json
+PACKAGE_NAME=$(node -p "require('./package.json').name")
+
+pnpm semantic-release -t "${PACKAGE_NAME}@\${version}" --no-ci