streamby-core 0.37.0 → 0.39.0

package/dist/services/pipeline.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePipeline = executePipeline;
+const connectionManager_1 = require("../adapters/database/connectionManager");
+const encryption_1 = require("../utils/encryption");
+const dbConnection_1 = require("./dbConnection");
+const jobQueue_1 = require("./jobQueue");
+const mediaProcessor_1 = require("./mediaProcessor");
+const vfxProcessor_1 = require("./vfxProcessor");
+const aiProcessor_1 = require("./aiProcessor");
+const storage_1 = require("../providers/storage");
+function applyFilterConfig(payload, config) {
+    const isArr = Array.isArray(payload);
+    let r = isArr ? [...payload] : payload;
+    if (config.conditions?.length) {
+        const matches = (item) => config.conditions.every(c => {
+            const v = item?.[c.field];
+            switch (c.op) {
+                case 'eq': return String(v) === c.value;
+                case 'neq': return String(v) !== c.value;
+                case 'gt': return Number(v) > Number(c.value);
+                case 'lt': return Number(v) < Number(c.value);
+                case 'gte': return Number(v) >= Number(c.value);
+                case 'lte': return Number(v) <= Number(c.value);
+                case 'contains': return String(v).includes(c.value);
+                case 'startsWith': return String(v).startsWith(c.value);
+                case 'endsWith': return String(v).endsWith(c.value);
+                default: return true;
+            }
+        });
+        r = isArr ? r.filter(matches) : (matches(r) ? r : null);
+        if (r === null)
+            return null;
+    }
+    if (config.includeFields?.length) {
+        const pick = (item) => {
+            if (!item || typeof item !== 'object')
+                return item;
+            const o = {};
+            for (const f of config.includeFields)
+                if (f in item)
+                    o[f] = item[f];
+            return o;
+        };
+        r = isArr ? r.map(pick) : pick(r);
+    }
+    if (config.renameFields?.length) {
+        const ren = (item) => {
+            if (!item || typeof item !== 'object')
+                return item;
+            const o = { ...item };
+            for (const { from, to } of config.renameFields) {
+                if (from in o) {
+                    o[to] = o[from];
+                    delete o[from];
+                }
+            }
+            return o;
+        };
+        r = isArr ? r.map(ren) : ren(r);
+    }
+    if (config.limit && isArr)
+        r = r.slice(0, config.limit);
+    if (config.wrapKey)
+        r = { [config.wrapKey]: r };
+    return r;
+}
+function getSources(nodes, edges, targetId, targetHandle) {
+    return edges
+        .filter(e => e.target === targetId && e.targetHandle === targetHandle)
+        .map(e => nodes.find(n => n.id === e.source))
+        .filter((n) => n !== undefined);
+}
+function getTarget(nodes, edges, sourceId, sourceHandle) {
+    const edge = edges.find(e => e.source === sourceId && e.sourceHandle === sourceHandle);
+    return edge ? (nodes.find(n => n.id === edge.target) ?? null) : null;
+}
+async function executePipeline(nodeSchema, project, config) {
+    const nodes = nodeSchema.nodes;
+    const edges = nodeSchema.edges;
+    // 1. Data layer — nodes connected to streamby in-bottom
+    const dataSources = getSources(nodes, edges, 'streamby', 'in-bottom');
+    const dataResults = [];
+    for (const node of dataSources) {
+        if (node.type === 'jsonInputNode') {
+            try {
+                dataResults.push(JSON.parse(node.data?.jsonString || 'null'));
+            }
+            catch {
+                dataResults.push(null);
+            }
+        }
+        else if (node.type === 'dataSourceNode') {
+            const tableName = (node.data?.tableName || node.data?.subtitle || node.data?.label);
+            if (!tableName)
+                continue;
+            const connectionId = node.data?.connectionId;
+            const recordId = node.data?.recordId;
+            const projectIdentifier = project._id?.toString() ?? project.id;
+            const fetchData = async (client, type) => recordId
+                ? (0, dbConnection_1.queryRecordByIdInternal)(client, type, tableName, recordId, projectIdentifier)
+                : (0, dbConnection_1.queryRecordsInternal)(client, type, tableName, 500, 0, projectIdentifier);
+            if (connectionId) {
+                const { client, type } = (0, connectionManager_1.getConnection)(connectionId);
+                dataResults.push(await fetchData(client, type));
+            }
+            else {
+                // legacy fallback for nodes saved before connectionId was introduced
+                const targetDb = config.databases?.find((db) => db.type === project.dbType && db.main)
+                    ?? config.databases?.find((db) => db.type === project.dbType);
+                if (!targetDb)
+                    throw new Error(`No database connection for type ${project.dbType}`);
+                const { client, type } = (0, connectionManager_1.getConnection)(targetDb.id);
+                dataResults.push(await fetchData(client, type));
+            }
+        }
+        else if (node.type === 'apiConnectionNode') {
+            const apiConnection = project.apiConnections?.find((c) => c.id === node.data?.connectionId);
+            if (!apiConnection)
+                continue;
+            const headers = { 'Content-Type': 'application/json' };
+            if (apiConnection.credentialId && (0, encryption_1.isEncryptionKeySet)()) {
+                const credential = project.credentials?.find((c) => c.id === apiConnection.credentialId);
+                if (credential) {
+                    const decrypted = (0, encryption_1.decrypt)(credential.encryptedValue);
+                    const prefix = apiConnection.prefix ? `${apiConnection.prefix} ` : '';
+                    headers['Authorization'] = `${prefix}${decrypted}`;
+                }
+            }
+            const response = await fetch(apiConnection.apiUrl, { method: apiConnection.method || 'GET', headers });
+            if (!response.ok)
+                throw new Error(`API connection fetch failed: ${response.statusText}`);
+            dataResults.push(await response.json());
+        }
+    }
+    let payload = dataResults.length === 1 ? dataResults[0] : dataResults;
+    // 2. Process layer — chain from streamby out-top → processNode in-process → out-process → ...
+    const adapter = (0, storage_1.createStorageProvider)(config.storageProviders);
+    const projectId = project._id?.toString() ?? project.id;
+    // userId is not available in pipeline context; use a sentinel for job attribution
+    const systemUserId = 'pipeline';
+    let processNode = getTarget(nodes, edges, 'streamby', 'out-top');
+    while (processNode) {
+        const nodeData = processNode.data ?? {};
+        const fileId = nodeData.fileId;
+        if (processNode.type === 'transcodeNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('transcode', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, mediaProcessor_1.runTranscodeJob)(job.jobId, fileId, projectId, {
+                codec: nodeData.codec,
+                resolution: nodeData.resolution,
+                outputFormat: nodeData.outputFormat,
+                bitrate: nodeData.bitrate,
+                audioCodec: nodeData.audioCodec,
+            }, adapter));
+            payload = { ...payload, jobId: job.jobId, jobType: 'transcode' };
+        }
+        else if (processNode.type === 'captionNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('caption', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, mediaProcessor_1.runCaptionJob)(job.jobId, fileId, projectId, {
+                sourceLanguage: nodeData.sourceLanguage,
+                outputFormat: nodeData.outputFormat,
+                provider: nodeData.provider,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'caption' };
+        }
+        else if (processNode.type === 'thumbnailNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('thumbnail', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, mediaProcessor_1.runThumbnailJob)(job.jobId, fileId, projectId, {
+                timecode: nodeData.timecode,
+                resolution: nodeData.resolution,
+                strategy: nodeData.strategy,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'thumbnail' };
+        }
+        else if (processNode.type === 'ingestNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('ingest', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, mediaProcessor_1.runIngestJob)(job.jobId, fileId, projectId));
+            payload = { ...payload, jobId: job.jobId, jobType: 'ingest' };
+        }
+        else if (processNode.type === 'renderJobNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('render', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, vfxProcessor_1.runRenderJob)(job.jobId, fileId, projectId, {
+                renderer: nodeData.renderer,
+                renderFarmConnectionId: nodeData.renderFarmConnectionId,
+                frameRange: nodeData.frameRange,
+                resolution: nodeData.resolution,
+                samples: nodeData.samples,
+                outputFormat: nodeData.outputFormat,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'render' };
+        }
+        else if (processNode.type === 'formatConvertNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('format-convert', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, vfxProcessor_1.runFormatConvertJob)(job.jobId, fileId, projectId, {
+                inputFormat: nodeData.inputFormat,
+                outputFormat: nodeData.outputFormat,
+                applyTransforms: nodeData.applyTransforms,
+                embedTextures: nodeData.embedTextures,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'format-convert' };
+        }
+        else if (processNode.type === 'lodNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('lod', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, vfxProcessor_1.runLodJob)(job.jobId, fileId, projectId, {
+                levels: nodeData.levels,
+                reductionRatios: nodeData.reductionRatios,
+                algorithm: nodeData.algorithm,
+                outputFormat: nodeData.outputFormat,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'lod' };
+        }
+        else if (processNode.type === 'qcCheckNode' && fileId) {
+            const checks = nodeData.checks ?? [];
+            const checkResults = checks.map((name) => ({
+                name, passed: true, value: 'ok', threshold: 'ok',
+            }));
+            payload = { ...payload, qcReport: { checks: checkResults, overallPassed: true } };
+        }
+        else if (processNode.type === 'transcriptionNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('transcription', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, aiProcessor_1.runTranscriptionJob)(job.jobId, fileId, projectId, {
+                model: nodeData.model,
+                sourceLanguage: nodeData.sourceLanguage,
+                outputFormats: nodeData.outputFormats,
+                provider: nodeData.provider,
+                credentialId: nodeData.credentialId,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'transcription' };
+        }
+        else if (processNode.type === 'upscaleNode' && fileId) {
+            const job = (0, jobQueue_1.createJob)('upscale', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, aiProcessor_1.runUpscaleJob)(job.jobId, fileId, projectId, {
+                scale: nodeData.scale,
+                model: nodeData.model,
+                mode: nodeData.mode,
+                credentialId: nodeData.credentialId,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'upscale' };
+        }
+        else if (processNode.type === 'proceduralAssetNode') {
+            const job = (0, jobQueue_1.createJob)('generate-asset', systemUserId, projectId, nodeData);
+            setImmediate(() => (0, aiProcessor_1.runGenerateAssetJob)(job.jobId, projectId, {
+                assetType: nodeData.assetType,
+                provider: nodeData.provider,
+                prompt: nodeData.prompt ?? '',
+                seed: nodeData.seed,
+                credentialId: nodeData.credentialId,
+            }));
+            payload = { ...payload, jobId: job.jobId, jobType: 'generate-asset' };
+        }
+        else if (processNode.type === 'pipelineSuggestNode') {
+            const suggestion = await (0, aiProcessor_1.buildPipelineSuggestion)({ nodes, edges }, Object.keys(nodeSchema));
+            payload = { ...payload, pipelineSuggestion: suggestion };
+        }
+        processNode = getTarget(nodes, edges, processNode.id, 'out-process');
+    }
+    // 3. Filter + output lane — streamby out-right → filterNode|annotationNode|deliverableNode|distributionNode
+    const outputLaneTypes = new Set(['filterNode', 'annotationNode', 'deliverableNode', 'distributionNode']);
+    let outputNode = getTarget(nodes, edges, 'streamby', 'out-right');
+    while (outputNode) {
+        if (outputNode.type === 'filterNode') {
+            const cfg = outputNode.data?.filterConfig;
+            if (cfg)
+                payload = applyFilterConfig(payload, cfg);
+        }
+        else if (outputNode.type === 'deliverableNode') {
+            payload = {
+                ...payload,
+                deliverable: {
+                    type: outputNode.data?.deliverableType ?? 'asset-bundle',
+                    version: outputNode.data?.deliverableVersion ?? '1.0.0',
+                },
+            };
+        }
+        else if (outputNode.type === 'distributionNode') {
+            // Distribution is async — the actual publish is handled by the host worker
+            payload = {
+                ...payload,
+                distribution: {
+                    target: outputNode.data?.distributionTarget,
+                    connectionId: outputNode.data?.distributionConnectionId,
+                    channel: outputNode.data?.channel,
+                    status: 'queued',
+                },
+            };
+        }
+        // annotationNode — pass-through; annotations are stored separately via the review API
+        const next = getTarget(nodes, edges, outputNode.id, 'out-filter');
+        outputNode = next && outputLaneTypes.has(next.type) ? next : null;
+    }
+    return payload;
+}

package/dist/services/production.d.ts

@@ -0,0 +1,2 @@
+/** A deleted project's sequences, shots, tasks and deliverables: only that project's. */
+export declare function deleteProductionData(projectId: string): Promise<void>;

package/dist/services/production.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteProductionData = deleteProductionData;
+const nosqlDb_1 = require("../utils/nosqlDb");
+/** A deleted project's sequences, shots, tasks and deliverables: only that project's. */
+async function deleteProductionData(projectId) {
+    const db = (0, nosqlDb_1.nosqlDb)();
+    if (!db || !projectId)
+        return;
+    for (const name of ['production_tasks', 'production_shots', 'production_sequences', 'deliverables']) {
+        await db.collection(name).deleteMany({ projectId });
+    }
+}

package/dist/services/productionFields.d.ts

@@ -0,0 +1,16 @@
+export declare const PRODUCTION_STATUSES: readonly ["todo", "in_progress", "review", "done"];
+export declare const TASK_PRIORITIES: readonly ["low", "medium", "high"];
+type Field = 'name' | 'description' | 'notes' | 'status' | 'priority' | 'assignees' | 'assignee' | 'dueDate' | 'order' | 'assetId' | 'exportId';
+export type FieldsResult = {
+    values: Record<string, any>;
+} | {
+    error: string;
+};
+/**
+ * The fields of `body` that `allowed` lists, checked and ready to save (`assignees` and
+ * `assignee` are saved as `assignedTo`). With `creating`, a name is required.
+ */
+export declare function checkProductionFields(body: any, allowed: readonly Field[], project: any, { creating }?: {
+    creating?: boolean | undefined;
+}): FieldsResult;
+export {};

package/dist/services/productionFields.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASK_PRIORITIES = exports.PRODUCTION_STATUSES = void 0;
+exports.checkProductionFields = checkProductionFields;
+const auth_1 = require("../utils/auth");
+// What a production sequence, shot or task may be given, checked before it's saved: a name
+// that isn't blank, a known status and priority, assignees who are members of the project, a
+// due date that is a date.
+exports.PRODUCTION_STATUSES = ['todo', 'in_progress', 'review', 'done'];
+exports.TASK_PRIORITIES = ['low', 'medium', 'high'];
+const MAX_NAME = 200;
+const MAX_TEXT = 5000;
+/**
+ * The fields of `body` that `allowed` lists, checked and ready to save (`assignees` and
+ * `assignee` are saved as `assignedTo`). With `creating`, a name is required.
+ */
+function checkProductionFields(body, allowed, project, { creating = false } = {}) {
+    const values = {};
+    const given = (field) => body?.[field] !== undefined;
+    const has = (field) => allowed.includes(field);
+    if (creating && !given('name'))
+        return { error: 'name is required' };
+    if (has('name') && given('name')) {
+        if (typeof body.name !== 'string' || !body.name.trim())
+            return { error: 'name must not be blank' };
+        if (body.name.trim().length > MAX_NAME)
+            return { error: `name must be at most ${MAX_NAME} characters` };
+        values.name = body.name.trim();
+    }
+    for (const field of ['description', 'notes']) {
+        if (!has(field) || !given(field))
+            continue;
+        const value = body[field];
+        if (value !== null && (typeof value !== 'string' || value.length > MAX_TEXT)) {
+            return { error: `${field} must be text of at most ${MAX_TEXT} characters, or null` };
+        }
+        values[field] = value === null || !value.trim() ? null : value;
+    }
+    if (has('status') && given('status')) {
+        if (!exports.PRODUCTION_STATUSES.includes(body.status))
+            return { error: `status must be one of ${exports.PRODUCTION_STATUSES.join(', ')}` };
+        values.status = body.status;
+    }
+    if (has('priority') && given('priority')) {
+        if (!exports.TASK_PRIORITIES.includes(body.priority))
+            return { error: `priority must be one of ${exports.TASK_PRIORITIES.join(', ')}` };
+        values.priority = body.priority;
+    }
+    const isMember = (id) => typeof id === 'string' && !!(0, auth_1.activeMemberOf)(project, id);
+    if (has('assignees') && given('assignedTo')) {
+        const ids = body.assignedTo;
+        if (!Array.isArray(ids) || !ids.every(isMember))
+            return { error: 'assignedTo must be a list of members of the project' };
+        values.assignedTo = [...new Set(ids)];
+    }
+    if (has('assignee') && given('assignedTo')) {
+        if (body.assignedTo !== null && !isMember(body.assignedTo))
+            return { error: 'assignedTo must be a member of the project, or null' };
+        values.assignedTo = body.assignedTo;
+    }
+    if (has('dueDate') && given('dueDate')) {
+        const date = body.dueDate === null || body.dueDate === '' ? null : new Date(body.dueDate);
+        if (date && Number.isNaN(date.getTime()))
+            return { error: 'dueDate must be a date, or null' };
+        values.dueDate = date;
+    }
+    if (has('order') && given('order')) {
+        if (typeof body.order !== 'number' || !Number.isFinite(body.order))
+            return { error: 'order must be a number' };
+        values.order = body.order;
+    }
+    for (const field of ['assetId', 'exportId']) {
+        if (!has(field) || !given(field))
+            continue;
+        if (body[field] !== null && typeof body[field] !== 'string')
+            return { error: `${field} must be an id, or null` };
+        values[field] = body[field] || null;
+    }
+    return { values };
+}

package/dist/services/signedUrls.d.ts

@@ -0,0 +1,6 @@
+import { Auth, StreamByConfig } from '../types';
+export declare const DEFAULT_TOKEN_SIGNED_URL_TTL: {
+    upload: number;
+    download: number;
+};
+export declare const signedUrlTtl: (auth: Auth | undefined, config: StreamByConfig, kind: "upload" | "download") => number | undefined;

package/dist/services/signedUrls.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signedUrlTtl = exports.DEFAULT_TOKEN_SIGNED_URL_TTL = void 0;
+// How long a signed storage URL works. A request made with an API token (an agent, the MCP
+// server) gets short-lived ones; a browser session, the adapter's own (an hour to upload, a
+// day to read).
+exports.DEFAULT_TOKEN_SIGNED_URL_TTL = { upload: 15 * 60, download: 5 * 60 };
+const signedUrlTtl = (auth, config, kind) => auth?.apiToken ? config.mcp?.signedUrlTtl?.[kind] ?? exports.DEFAULT_TOKEN_SIGNED_URL_TTL[kind] : undefined;
+exports.signedUrlTtl = signedUrlTtl;

package/dist/types/index.d.ts

@@ -42,10 +42,11 @@ export interface StorageAdapter {
     deleteProjectDirectory: (projectId: string) => Promise<any>;
     getPresignedUrl?: (contentType: string, projectId: string) => Promise<any>;
     getPresignedProjectImageUrl?: (projectId: string) => Promise<any>;
-    getPresignedUploadUrl?: (key: string, contentType: string) => Promise<string>;
+    getPresignedUploadUrl?: (key: string, contentType: string, expiresIn?: number) => Promise<string>;
     listFilesByCategory?: (projectId: string, category: string) => Promise<StorageFileInfo[]>;
     deleteFile?: (key: string) => Promise<void>;
-    getPresignedGetUrl?: (key: string) => Promise<string>;
+    copyFile?: (from: string, to: string) => Promise<void>;
+    getPresignedGetUrl?: (key: string, expiresIn?: number, downloadName?: string) => Promise<string>;
 }
 export interface FieldDefinition {
     name: string;
@@ -140,6 +141,10 @@ export interface StreamByConfig {
             windowMs: number;
         };
         apiBaseUrl?: string;
+        signedUrlTtl?: {
+            upload?: number;
+            download?: number;
+        };
     };
     websocket?: {
         server: WebSocketServer;

package/dist/utils/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function encrypt(text: string, secretKey: string): string;
+export declare function decrypt(text: string, secretKey: string): string;
+export declare function hash(text: string): string;

package/dist/utils/crypto.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+exports.hash = hash;
+const crypto_1 = __importDefault(require("crypto"));
+const ALGORITHM = 'aes-256-cbc';
+const IV_LENGTH = 16;
+function encrypt(text, secretKey) {
+    const iv = crypto_1.default.randomBytes(IV_LENGTH);
+    const key = crypto_1.default.createHash('sha256').update(String(secretKey)).digest('base64').substr(0, 32);
+    const cipher = crypto_1.default.createCipheriv(ALGORITHM, Buffer.from(key), iv);
+    let encrypted = cipher.update(text);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return iv.toString('hex') + ':' + encrypted.toString('hex');
+}
+function decrypt(text, secretKey) {
+    const textParts = text.split(':');
+    const iv = Buffer.from(textParts.shift(), 'hex');
+    const encryptedText = Buffer.from(textParts.join(':'), 'hex');
+    const key = crypto_1.default.createHash('sha256').update(String(secretKey)).digest('base64').substr(0, 32);
+    const decipher = crypto_1.default.createDecipheriv(ALGORITHM, Buffer.from(key), iv);
+    let decrypted = decipher.update(encryptedText);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return decrypted.toString();
+}
+function hash(text) {
+    return crypto_1.default.createHash('sha256').update(text).digest('hex');
+}

package/dist/utils/nosqlDb.d.ts

@@ -0,0 +1,2 @@
+/** The NoSQL database the project's files and production live in, or null when there's none. */
+export declare function nosqlDb(): import("mongodb").Db | null;

package/dist/utils/nosqlDb.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nosqlDb = nosqlDb;
+const connectionManager_1 = require("../adapters/database/connectionManager");
+/** The NoSQL database the project's files and production live in, or null when there's none. */
+function nosqlDb() {
+    const ids = (0, connectionManager_1.getConnectedIds)().filter(id => (0, connectionManager_1.getConnection)(id).type === 'nosql');
+    if (!ids.length)
+        return null;
+    return (0, connectionManager_1.getConnection)(ids[0]).client.db();
+}

package/dist/utils/sanitize.d.ts

@@ -14,5 +14,6 @@ export declare function sanitizeIntegrationConnection<T extends object>(conn: T)
 export declare function sanitizeIntegrationConnections<T extends object>(conns: T[] | undefined): (T & {
     hasCredential: true;
 })[];
+export declare function exportSummaries(exports: any[] | undefined): any[];
 export declare function sanitizeProject(project: any): any;
 export declare function sanitizeUserIntegration(integration: any): any;

package/dist/utils/sanitize.js

@@ -4,6 +4,7 @@ exports.sanitizeConnection = sanitizeConnection;
 exports.sanitizeConnections = sanitizeConnections;
 exports.sanitizeIntegrationConnection = sanitizeIntegrationConnection;
 exports.sanitizeIntegrationConnections = sanitizeIntegrationConnections;
+exports.exportSummaries = exportSummaries;
 exports.sanitizeProject = sanitizeProject;
 exports.sanitizeUserIntegration = sanitizeUserIntegration;
 function sanitizeConnection(conn) {
@@ -23,6 +24,19 @@ function sanitizeIntegrationConnection(conn) {
 function sanitizeIntegrationConnections(conns) {
     return (conns ?? []).map(sanitizeIntegrationConnection);
 }
+// A project's exports as they're listed: what each one is, not its schema nor its credentials.
+// The same in the project (GET /projects/:id) and in its own list (GET /projects/:id/exports).
+function exportSummaries(exports) {
+    return (exports || []).map((e) => ({
+        id: e.id,
+        name: e.name,
+        description: e.description,
+        method: e.method,
+        private: e.private,
+        useConnections: e.useConnections,
+        useCredentials: e.useCredentials,
+    }));
+}
 function sanitizeProject(project) {
     if (!project)
         return project;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamby-core",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "description": "StreamBy middleware framework for media storage management",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",