@tuturuuu/internal-api 0.0.1

package/dist/storage.js

@@ -0,0 +1,371 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadWorkspaceStorageFile = uploadWorkspaceStorageFile;
+exports.uploadWorkspaceUserGroupStorageFile = uploadWorkspaceUserGroupStorageFile;
+exports.uploadWorkspaceTaskFile = uploadWorkspaceTaskFile;
+exports.createWorkspaceStorageUploadUrl = createWorkspaceStorageUploadUrl;
+exports.createWorkspaceUserGroupStorageUploadUrl = createWorkspaceUserGroupStorageUploadUrl;
+exports.createWorkspaceTaskUploadUrl = createWorkspaceTaskUploadUrl;
+exports.createWorkspaceStorageSignedUrl = createWorkspaceStorageSignedUrl;
+exports.migrateWorkspaceStorage = migrateWorkspaceStorage;
+exports.listWorkspaceStorageObjects = listWorkspaceStorageObjects;
+exports.listWorkspaceUserGroupStorageFiles = listWorkspaceUserGroupStorageFiles;
+exports.getWorkspaceStorageAnalytics = getWorkspaceStorageAnalytics;
+exports.exportWorkspaceStorageLinks = exportWorkspaceStorageLinks;
+exports.deleteWorkspaceStorageObject = deleteWorkspaceStorageObject;
+exports.deleteWorkspaceUserGroupStorageFile = deleteWorkspaceUserGroupStorageFile;
+exports.deleteWorkspaceStorageObjects = deleteWorkspaceStorageObjects;
+exports.createWorkspaceStorageFolder = createWorkspaceStorageFolder;
+exports.renameWorkspaceStorageObject = renameWorkspaceStorageObject;
+exports.deleteWorkspaceStorageFolder = deleteWorkspaceStorageFolder;
+const client_1 = require("./client");
+function uploadFileWithXhr(file, uploadUrlResult, headers, onProgress) {
+    return new Promise((resolve, reject) => {
+        const xhr = new XMLHttpRequest();
+        xhr.upload.onprogress = (event) => {
+            const total = event.lengthComputable ? event.total : file.size || null;
+            const loaded = event.loaded;
+            const percent = total && total > 0
+                ? Math.min(99, Math.round((loaded / total) * 100))
+                : 0;
+            onProgress({
+                loaded,
+                percent,
+                total,
+            });
+        };
+        xhr.onload = () => {
+            if (xhr.status >= 200 && xhr.status < 300) {
+                onProgress({
+                    loaded: file.size,
+                    percent: 100,
+                    total: file.size,
+                });
+                resolve();
+                return;
+            }
+            reject(new Error(`Failed to upload file (${xhr.status})${xhr.responseText ? `: ${xhr.responseText}` : ''}`));
+        };
+        xhr.onerror = () => {
+            reject(new Error('Failed to upload file'));
+        };
+        xhr.onabort = () => {
+            reject(new Error('Upload aborted'));
+        };
+        xhr.open('PUT', uploadUrlResult.signedUrl);
+        for (const [key, value] of Object.entries(headers)) {
+            xhr.setRequestHeader(key, value);
+        }
+        xhr.send(file);
+    });
+}
+async function uploadFileWithSignedUrl(file, uploadUrlResult, fetchImpl, onProgress, onUploaded) {
+    const headers = {
+        ...(uploadUrlResult.headers ?? {}),
+    };
+    if (!headers['Content-Type']) {
+        headers['Content-Type'] = file.type || 'application/octet-stream';
+    }
+    if (uploadUrlResult.token) {
+        headers.Authorization = `Bearer ${uploadUrlResult.token}`;
+    }
+    if (onProgress && typeof XMLHttpRequest !== 'undefined') {
+        try {
+            await uploadFileWithXhr(file, uploadUrlResult, headers, onProgress);
+        }
+        catch (error) {
+            const fallbackHeaders = { ...headers };
+            delete fallbackHeaders['Content-Type'];
+            await uploadFileWithXhr(file, uploadUrlResult, fallbackHeaders, onProgress).catch(() => {
+                throw error;
+            });
+        }
+    }
+    else {
+        let uploadResponse = await fetchImpl(uploadUrlResult.signedUrl, {
+            method: 'PUT',
+            cache: 'no-store',
+            headers,
+            body: file,
+        });
+        if (!uploadResponse.ok) {
+            const fallbackHeaders = { ...headers };
+            delete fallbackHeaders['Content-Type'];
+            uploadResponse = await fetchImpl(uploadUrlResult.signedUrl, {
+                method: 'PUT',
+                cache: 'no-store',
+                headers: fallbackHeaders,
+                body: file,
+            });
+        }
+        if (!uploadResponse.ok) {
+            const message = await uploadResponse.text().catch(() => '');
+            throw new Error(`Failed to upload file (${uploadResponse.status})${message ? `: ${message}` : ''}`);
+        }
+        onProgress?.({
+            loaded: file.size,
+            percent: 100,
+            total: file.size,
+        });
+    }
+    const result = {
+        path: uploadUrlResult.path,
+        fullPath: uploadUrlResult.fullPath,
+    };
+    const postUploadData = (await onUploaded?.(result)) ?? {};
+    return {
+        ...result,
+        ...postUploadData,
+    };
+}
+function parseSignedUploadPayload(payload) {
+    if (!payload.signedUrl || !payload.path) {
+        throw new Error('Missing upload URL payload');
+    }
+    return {
+        signedUrl: payload.signedUrl,
+        token: payload.token,
+        headers: payload.headers,
+        path: payload.path,
+        fullPath: payload.fullPath ?? null,
+    };
+}
+async function uploadWorkspaceStorageFile(workspaceId, file, options, clientOptions) {
+    const fetchImpl = clientOptions?.fetch ?? globalThis.fetch;
+    const { onUploadProgress, ...uploadOptions } = options ?? {};
+    const uploadUrlResult = await createWorkspaceStorageUploadUrl(workspaceId, file.name, {
+        ...uploadOptions,
+        size: file.size,
+    }, clientOptions);
+    return uploadFileWithSignedUrl(file, uploadUrlResult, fetchImpl, onUploadProgress, async (result) => {
+        try {
+            const finalized = await finalizeWorkspaceStorageUpload(workspaceId, {
+                path: result.path,
+                contentType: file.type || 'application/octet-stream',
+                originalFilename: file.name,
+            }, clientOptions);
+            return {
+                autoExtract: finalized.autoExtract,
+                finalize: {
+                    success: true,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                finalize: {
+                    success: false,
+                    error: error instanceof Error
+                        ? error.message
+                        : 'Failed to finalize upload',
+                },
+            };
+        }
+    });
+}
+async function uploadWorkspaceUserGroupStorageFile(workspaceId, groupId, file, options, clientOptions) {
+    const fetchImpl = clientOptions?.fetch ?? globalThis.fetch;
+    const { onUploadProgress, upsert } = options ?? {};
+    const uploadUrlResult = await createWorkspaceUserGroupStorageUploadUrl(workspaceId, groupId, file.name, {
+        size: file.size,
+        upsert,
+    }, clientOptions);
+    return uploadFileWithSignedUrl(file, uploadUrlResult, fetchImpl, onUploadProgress, async (result) => {
+        const finalized = await finalizeWorkspaceStorageUpload(workspaceId, {
+            path: result.path,
+            contentType: file.type || 'application/octet-stream',
+            originalFilename: file.name,
+        }, clientOptions);
+        return {
+            autoExtract: finalized.autoExtract,
+            finalize: {
+                success: true,
+            },
+        };
+    });
+}
+async function uploadWorkspaceTaskFile(workspaceId, file, options, clientOptions) {
+    const fetchImpl = clientOptions?.fetch ?? globalThis.fetch;
+    const { onUploadProgress, ...uploadOptions } = options ?? {};
+    const uploadUrlResult = await createWorkspaceTaskUploadUrl(workspaceId, file.name, uploadOptions, clientOptions);
+    return uploadFileWithSignedUrl(file, uploadUrlResult, fetchImpl, onUploadProgress);
+}
+async function finalizeWorkspaceStorageUpload(workspaceId, payload, clientOptions) {
+    const client = (0, client_1.getInternalApiClient)(clientOptions);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/finalize-upload`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+        cache: 'no-store',
+    });
+}
+async function createWorkspaceStorageUploadUrl(workspaceId, filename, options, clientOptions) {
+    const client = (0, client_1.getInternalApiClient)(clientOptions);
+    const payload = await client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/upload-url`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            filename,
+            path: options?.path,
+            upsert: options?.upsert,
+            size: options?.size,
+        }),
+        cache: 'no-store',
+    });
+    return parseSignedUploadPayload(payload);
+}
+async function createWorkspaceUserGroupStorageUploadUrl(workspaceId, groupId, filename, options, clientOptions) {
+    const client = (0, client_1.getInternalApiClient)(clientOptions);
+    const payload = await client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/user-groups/${(0, client_1.encodePathSegment)(groupId)}/storage`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            filename,
+            upsert: options?.upsert,
+            size: options?.size,
+        }),
+        cache: 'no-store',
+    });
+    return parseSignedUploadPayload(payload);
+}
+async function createWorkspaceTaskUploadUrl(workspaceId, filename, options, clientOptions) {
+    const client = (0, client_1.getInternalApiClient)(clientOptions);
+    const payload = await client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/tasks/upload-url`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            filename,
+            taskId: options?.taskId,
+        }),
+        cache: 'no-store',
+    });
+    return parseSignedUploadPayload(payload);
+}
+async function createWorkspaceStorageSignedUrl(workspaceId, path, expiresIn = 60 * 60 * 24, transform, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    const payload = await client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/share`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ path, expiresIn, transform }),
+        cache: 'no-store',
+    });
+    if (!payload.signedUrl) {
+        throw new Error('Missing signed URL');
+    }
+    return payload.signedUrl;
+}
+async function migrateWorkspaceStorage(workspaceId, payload, clientOptions) {
+    const client = (0, client_1.getInternalApiClient)(clientOptions);
+    const response = await client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/migrate`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+        cache: 'no-store',
+    });
+    return response.data;
+}
+async function listWorkspaceStorageObjects(workspaceId, query, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/list`, {
+        query,
+        cache: 'no-store',
+    });
+}
+async function listWorkspaceUserGroupStorageFiles(workspaceId, groupId, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    const response = await client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/user-groups/${(0, client_1.encodePathSegment)(groupId)}/storage`, {
+        cache: 'no-store',
+    });
+    return response.data;
+}
+async function getWorkspaceStorageAnalytics(workspaceId, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/analytics`, {
+        cache: 'no-store',
+    });
+}
+async function exportWorkspaceStorageLinks(workspaceId, payload, clientOptions) {
+    const client = (0, client_1.getInternalApiClient)(clientOptions);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/export-links`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+        cache: 'no-store',
+    });
+}
+async function deleteWorkspaceStorageObject(workspaceId, path, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/object`, {
+        method: 'DELETE',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ path }),
+        cache: 'no-store',
+    });
+}
+async function deleteWorkspaceUserGroupStorageFile(workspaceId, groupId, filename, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/user-groups/${(0, client_1.encodePathSegment)(groupId)}/storage`, {
+        method: 'DELETE',
+        query: { filename },
+        cache: 'no-store',
+    });
+}
+async function deleteWorkspaceStorageObjects(workspaceId, paths, options) {
+    await Promise.all(paths.map((path) => deleteWorkspaceStorageObject(workspaceId, path, options)));
+    return {
+        message: `Successfully deleted ${paths.length} file(s)`,
+        data: {
+            deleted: paths.length,
+            paths,
+        },
+    };
+}
+async function createWorkspaceStorageFolder(workspaceId, payload, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/folders`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+        cache: 'no-store',
+    });
+}
+async function renameWorkspaceStorageObject(workspaceId, payload, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/rename`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+        cache: 'no-store',
+    });
+}
+async function deleteWorkspaceStorageFolder(workspaceId, payload, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/v1/workspaces/${(0, client_1.encodePathSegment)(workspaceId)}/storage/folders`, {
+        method: 'DELETE',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+        cache: 'no-store',
+    });
+}

package/dist/tasks-scheduling.d.ts

@@ -0,0 +1,14 @@
+import type { TaskPriority } from '@tuturuuu/types/primitives/Priority';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import type { InternalApiClientOptions } from './client';
+export interface TaskSchedulingUpdatePayload {
+    total_duration?: number | null;
+    is_splittable?: boolean | null;
+    min_split_duration_minutes?: number | null;
+    max_split_duration_minutes?: number | null;
+    calendar_hours?: Task['calendar_hours'] | null;
+    auto_schedule?: boolean;
+    priority?: TaskPriority | null;
+}
+export declare function updateTaskSchedulingSettings(wsId: string, taskId: string, payload: TaskSchedulingUpdatePayload, options?: InternalApiClientOptions): Promise<Task>;
+//# sourceMappingURL=tasks-scheduling.d.ts.map

package/dist/tasks-scheduling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-scheduling.d.ts","sourceRoot":"","sources":["../src/tasks-scheduling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACxE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAGzD,MAAM,WAAW,2BAA2B;IAC1C,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,aAAa,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,0BAA0B,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,0BAA0B,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3C,cAAc,CAAC,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC;IAC/C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CAChC;AAED,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,2BAA2B,EACpC,OAAO,CAAC,EAAE,wBAAwB,iBAanC"}

package/dist/tasks-scheduling.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTaskSchedulingSettings = updateTaskSchedulingSettings;
+const client_1 = require("./client");
+async function updateTaskSchedulingSettings(wsId, taskId, payload, options) {
+    const client = (0, client_1.getInternalApiClient)(options);
+    return client.json(`/api/${(0, client_1.encodePathSegment)(wsId)}/task/${(0, client_1.encodePathSegment)(taskId)}/edit`, {
+        method: 'PATCH',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+    });
+}