streamby-core 0.29.8 → 0.29.11

package/dist/services/userIntegration.d.ts

@@ -0,0 +1,17 @@
+import { IntegrationKind, UserIntegration } from '../types';
+export declare function listUserIntegrations(userId: string): Promise<UserIntegration[]>;
+export declare function createUserIntegration(userId: string, input: {
+    kind: IntegrationKind;
+    provider: string;
+    name: string;
+    description?: string;
+    credentialValue: unknown;
+}): Promise<UserIntegration>;
+export declare function updateUserIntegration(userId: string, integrationId: string, updates: {
+    name?: string;
+    description?: string;
+    credentialValue?: unknown;
+}): Promise<UserIntegration | null>;
+export declare function deleteUserIntegration(userId: string, integrationId: string): Promise<boolean>;
+export declare function getDecryptedIntegrationCredential(userId: string, integrationId: string): Promise<unknown | null>;
+export declare function getDecryptedIntegrationCredentialById(integrationId: string): Promise<unknown | null>;

package/dist/services/userIntegration.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listUserIntegrations = listUserIntegrations;
+exports.createUserIntegration = createUserIntegration;
+exports.updateUserIntegration = updateUserIntegration;
+exports.deleteUserIntegration = deleteUserIntegration;
+exports.getDecryptedIntegrationCredential = getDecryptedIntegrationCredential;
+exports.getDecryptedIntegrationCredentialById = getDecryptedIntegrationCredentialById;
+const crypto_1 = __importDefault(require("crypto"));
+const manager_1 = require("../models/manager");
+const encryption_1 = require("../utils/encryption");
+function encryptCredential(kind, value) {
+    return kind === 'storage' ? (0, encryption_1.encrypt)(JSON.stringify(value)) : (0, encryption_1.encrypt)(String(value));
+}
+async function listUserIntegrations(userId) {
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    return UserIntegrationModel.find({ userId });
+}
+async function createUserIntegration(userId, input) {
+    if (!(0, encryption_1.isEncryptionKeySet)()) {
+        throw new Error('Encryption key is not set. Cannot create integration.');
+    }
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    const now = new Date();
+    const integration = {
+        id: crypto_1.default.randomUUID(),
+        userId,
+        kind: input.kind,
+        provider: input.provider,
+        name: input.name,
+        description: input.description,
+        encryptedCredential: encryptCredential(input.kind, input.credentialValue),
+        createdAt: now,
+        updatedAt: now,
+    };
+    return UserIntegrationModel.create(integration);
+}
+async function updateUserIntegration(userId, integrationId, updates) {
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    const existing = await UserIntegrationModel.findOne({ id: integrationId, userId });
+    if (!existing)
+        return null;
+    const $set = { updatedAt: new Date() };
+    if (updates.name !== undefined)
+        $set.name = updates.name;
+    if (updates.description !== undefined)
+        $set.description = updates.description;
+    if (updates.credentialValue !== undefined) {
+        if (!(0, encryption_1.isEncryptionKeySet)()) {
+            throw new Error('Encryption key is not set. Cannot update integration.');
+        }
+        $set.encryptedCredential = encryptCredential(existing.kind, updates.credentialValue);
+    }
+    return UserIntegrationModel.update({ id: integrationId, userId }, $set);
+}
+async function deleteUserIntegration(userId, integrationId) {
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    const deletedCount = await UserIntegrationModel.delete({ id: integrationId, userId });
+    return deletedCount > 0;
+}
+async function getDecryptedIntegrationCredential(userId, integrationId) {
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    const integration = await UserIntegrationModel.findOne({ id: integrationId, userId });
+    return decryptIntegration(integration);
+}
+// Used when resolving a project connection's `integrationId` at connection-use time — the
+// project already validated ownership when the connection was created (see project.ts /
+// dbConnection.ts POST), so there's no userId to filter by here, only the integrationId
+// stored on the connection itself.
+async function getDecryptedIntegrationCredentialById(integrationId) {
+    const UserIntegrationModel = (0, manager_1.getModel)('user_integrations');
+    const integration = await UserIntegrationModel.findOne({ id: integrationId });
+    return decryptIntegration(integration);
+}
+async function decryptIntegration(integration) {
+    if (!integration)
+        return null;
+    if (!(0, encryption_1.isEncryptionKeySet)()) {
+        throw new Error('Encryption key is not set. Cannot decrypt integration credential.');
+    }
+    const decrypted = (0, encryption_1.decrypt)(integration.encryptedCredential);
+    return integration.kind === 'storage' ? JSON.parse(decrypted) : decrypted;
+}

package/dist/types/index.d.ts

@@ -17,8 +17,12 @@ export interface StorageConnection {
     createdAt: Date;
     description?: string;
     isBuiltin?: boolean;
+    integrationId?: string;
+    source?: 'builtin' | 'integration' | 'manual';
+    available?: boolean;
 }
 export type StorageProvider = {
+    id: string;
     type: StorageProviderType;
     config: S3Config;
 };
@@ -74,6 +78,7 @@ export interface ProjectInfo {
     dbConnections?: DbConnection[];
     storageConnections?: StorageConnection[];
     pipelines?: PipelineRef[];
+    builtinBackfilledAt?: Date;
 }
 export interface Credential {
     id: string;
@@ -107,10 +112,7 @@ export interface DatabaseCredential {
     main?: boolean;
 }
 export interface StreamByConfig {
-    storageProviders: {
-        type: StorageProviderType;
-        config: S3Config;
-    }[];
+    storageProviders: StorageProvider[];
     authProvider: AuthProvider;
     databases?: DatabaseCredential[];
     adapter?: StorageAdapter;
@@ -118,6 +120,7 @@ export interface StreamByConfig {
     websocket?: {
         server: WebSocketServer;
     };
+    canUseBuiltin?: (auth: Auth, builtinId: string, kind: 'database' | 'storage') => boolean | Promise<boolean>;
 }
 export interface Notification {
     _id?: string;
@@ -154,6 +157,21 @@ export interface DbConnection {
     projectId: string;
     createdAt: Date;
     description?: string;
+    isBuiltin?: boolean;
+    integrationId?: string;
+    source?: 'builtin' | 'integration' | 'manual';
+}
+export type IntegrationKind = 'database' | 'storage';
+export interface UserIntegration {
+    id: string;
+    userId: string;
+    kind: IntegrationKind;
+    provider: ExternalDbType | StorageProviderType;
+    name: string;
+    description?: string;
+    encryptedCredential: string;
+    createdAt: Date;
+    updatedAt: Date;
 }
 export interface ColumnDefinition {
     name: string;

package/dist/utils/builtinAccess.d.ts

@@ -0,0 +1,6 @@
+import { Auth, StreamByConfig } from '../types';
+export declare function assertBuiltinAccess(auth: Auth, builtinId: string, config: StreamByConfig, kind: 'database' | 'storage'): Promise<boolean>;
+export declare function isBuiltinStorageId(id: string, config: StreamByConfig): boolean;
+export declare function isBuiltinDb(id: string, config: StreamByConfig): boolean;
+export declare const BUILTIN_STORAGE_DISPLAY: Record<string, string>;
+export declare const BUILTIN_DB_DISPLAY: Record<string, string>;

package/dist/utils/builtinAccess.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_DB_DISPLAY = exports.BUILTIN_STORAGE_DISPLAY = void 0;
+exports.assertBuiltinAccess = assertBuiltinAccess;
+exports.isBuiltinStorageId = isBuiltinStorageId;
+exports.isBuiltinDb = isBuiltinDb;
+// Gates access to a built-in database/storage provider. Delegates to config.canUseBuiltin
+// when the mounting app implements it (e.g. Nhexa-API checking user_subscriptions);
+// defaults to allow when absent, preserving pre-BYOC behavior for deploys without gating.
+async function assertBuiltinAccess(auth, builtinId, config, kind) {
+    if (!config.canUseBuiltin)
+        return true;
+    return config.canUseBuiltin(auth, builtinId, kind);
+}
+function isBuiltinStorageId(id, config) {
+    return (config.storageProviders ?? []).some(p => p.id === id);
+}
+function isBuiltinDb(id, config) {
+    return (config.databases ?? []).some(db => db.id === id);
+}
+// Display names for builtin connections — never the raw config id/type. The frontend pairs
+// this with the StreamBy icon to visually mark a connection as built-in vs BYOC.
+exports.BUILTIN_STORAGE_DISPLAY = {
+    s3: 'AWS S3',
+    gcs: 'Google Cloud Storage',
+    r2: 'Cloudflare R2',
+    azure: 'Azure Blob Storage',
+};
+exports.BUILTIN_DB_DISPLAY = {
+    sql: 'PostgreSQL',
+    nosql: 'MongoDB',
+};

package/dist/utils/sanitize.d.ts

@@ -1 +1,2 @@
 export declare function sanitizeProject(project: any): any;
+export declare function sanitizeUserIntegration(integration: any): any;

package/dist/utils/sanitize.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sanitizeProject = sanitizeProject;
+exports.sanitizeUserIntegration = sanitizeUserIntegration;
 function sanitizeProject(project) {
     if (!project)
         return project;
@@ -9,3 +10,9 @@ function sanitizeProject(project) {
         credentials: project.credentials?.map(({ id, key }) => ({ id, key })) ?? [],
     };
 }
+function sanitizeUserIntegration(integration) {
+    if (!integration)
+        return integration;
+    const { encryptedCredential, ...rest } = integration;
+    return rest;
+}

package/package.json

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