streamby-core 0.23.5 → 0.24.1

package/README.md

@@ -1,206 +1,242 @@
-# @streamby/core
-
-Middleware framework for building storage-agnostic media APIs.  
-Part of the [StreamBy](https://streamby.nhexa.cl) ecosystem by TerminalCore Labs.
-
----
-
-## 🚀 What is it?
-
-`@streamby/core` is a plug-and-play middleware for Express (or compatible frameworks) that enables file uploads, listings and **multi-project access** over services like:
-
-- ✅ AWS S3
-- ✅ Google Cloud Storage (soon)
-- ✅ Cloudflare R2 (soon)
-- ✅ Local/Personal servers (soon)
-
-It's designed to be installed inside your existing API as a library — **no need to run a separate backend**.
-
----
-
-## 📦 Installation
-
-```bash
-npm install @streamby/core
-```
-
----
-
-## 🧱 Basic usage
-
-```ts
-import express from 'express';
-import { createStreamByRouter } from '@streamby/core';
-
-const app = express();
-
-app.use('/streamby', createStreamByRouter({
-  storageProvider: {
-    type: 's3',
-    config: {
-      bucket: 'your-bucket-name',
-      region: 'your-region',
-      accessKeyId: 'YOUR_AWS_KEY',
-      secretAccessKey: 'YOUR_AWS_SECRET'
-    }
-  },
-  authProvider: async (req) => {
-    // extract token/cookie and validate
-    return {
-      userId: 'demo',
-      projects: ['demo-project'],
-      role: 'admin',
-    };
-  },
-  projectProvider: async (projectId) => {
-    // fetch project from your DB
-    return {
-      id: projectId,
-      name: 'Demo Project',
-      description: 'Demo for StreamBy integration',
-      rootFolders: [],
-      settings: { allowUpload: true }
-    };
-  }
-}));
-
-app.listen(3000);
-```
-
----
-
-## 🧪 Testing
-
-```bash
-npm run test
-```
-
-Unit tests use [Vitest](https://vitest.dev) and [Supertest](https://www.npmjs.com/package/supertest).
-
----
-
-## 📁 Features
-
-- 📂 Multi-project access control
-- 🔐 Project-aware file uploads & listings
-- 🧹 Modular adapters per storage provider
-- 🧰 Built-in testability with mock auth & storage
-- ✨ Simple to extend for custom business logic
-
----
-
-## 🗺️ API Endpoints
-
-Here's a summary of the key API endpoints provided by `@streamby/core`:
-
-### `GET /streamby/projects`
-
-Lists all projects accessible by the authenticated user.
-
-**Query Parameters:**
-- `archived`: (Optional) Filter projects by their archived status.
-  - `true`: Returns only archived projects.
-  - `false`: Returns only unarchived projects.
-  - (Omitted): Returns all projects (both archived and unarchived).
-
-**Example Response:**
-```json
-{
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": false
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": true
-    }
-  ]
-}
-```
-
-### `PATCH /streamby/projects/:id/archive`
-
-Archives a specific project. After archiving, it returns the complete list of projects for the user, including the updated project.
-
-**Example Response:**
-```json
-{
-  "success": true,
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": true
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": false
-    }
-  ]
-}
-```
-
-### `PATCH /streamby/projects/:id/unarchive`
-
-Unarchives a specific project. After unarchiving, it returns the complete list of projects for the user, including the updated project.
-
-**Example Response:**
-```json
-{
-  "success": true,
-  "projects": [
-    {
-      "id": "project1_id",
-      "dbType": "nosql",
-      "name": "My NoSQL Project",
-      "image": "url_to_image",
-      "archived": false
-    },
-    {
-      "id": "project2_id",
-      "dbType": "sql",
-      "name": "My SQL Project",
-      "image": "url_to_image",
-      "archived": false
-    }
-  ]
-}
-```
-
----
-
-## 🚣 Roadmap
-
-- [ ] Support for Google Cloud Storage
-- [ ] CLI tool for uploading files
-- [ ] Role-based access control middleware
-- [ ] Plugin system for extended routes
-- [ ] Streaming support (HLS, audio, etc.)
-
----
-
-## 🧑‍💻 Maintained by
-
-**TerminalCore Labs** – part of [Nhexa Entertainment](https://nhexa.cl)  
-Developed as open-source infrastructure for creative and media-oriented apps.
-
-Visit us [here](https://terminalcore.cl)
-
----
-
-## 📟 License
-
-[MIT](./LICENSE)
-
+# @streamby/core
+
+Middleware framework for building storage-agnostic media APIs.  
+Part of the [StreamBy](https://streamby.nhexa.cl) ecosystem by TerminalCore Labs.
+
+---
+
+## 🚀 What is it?
+
+`@streamby/core` is a plug-and-play middleware for Express (or compatible frameworks) that enables file uploads, listings and **multi-project access** over services like:
+
+- ✅ AWS S3
+- ✅ Google Cloud Storage (soon)
+- ✅ Cloudflare R2 (soon)
+- ✅ Local/Personal servers (soon)
+
+It's designed to be installed inside your existing API as a library — **no need to run a separate backend**.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @streamby/core
+```
+
+---
+
+## 🧱 Basic usage
+
+---
+
+## 🗄️ Database Schema Setup
+
+`@streamby/core` requires a pre-configured database schema for its internal operations. It does not manage database connections directly; instead, it expects the host application to provide initialized connection instances. This ensures full control and flexibility for the host environment.
+
+The library will only interact with the specified schema and will not touch other schemas in your database. The `reset` option is opt-in and will only drop and recreate the specified `streamby` schema if explicitly set to `true`.
+
+### PostgreSQL Example
+
+```ts
+import { Pool } from "pg";
+import { setupStreambyPg } from "@streamby/core/pg/setup"; // Adjust path as per your package structure
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+// Call setupStreambyPg to ensure the schema and tables are created
+// reset: false (default) ensures idempotency and no data loss
+await setupStreambyPg({ pool, schema: "streamby", reset: false });
+```
+
+### MongoDB Example
+
+```ts
+import { MongoClient } from "mongodb";
+import { setupStreambyMongo } from "@streamby/core/mongo/setup"; // Adjust path as per your package structure
+
+const client = new MongoClient(process.env.MONGO_URL!);
+
+// Connect the MongoDB client
+await client.connect();
+
+// Call setupStreambyMongo to ensure collections and indexes are created
+await setupStreambyMongo({ client, dbName: "streamby" });
+```
+
+```ts
+import express from 'express';
+import { createStreamByRouter } from '@streamby/core';
+
+const app = express();
+
+app.use('/streamby', createStreamByRouter({
+  storageProvider: {
+    type: 's3',
+    config: {
+      bucket: 'your-bucket-name',
+      region: 'your-region',
+      accessKeyId: 'YOUR_AWS_KEY',
+      secretAccessKey: 'YOUR_AWS_SECRET'
+    }
+  },
+  authProvider: async (req) => {
+    // extract token/cookie and validate
+    return {
+      userId: 'demo',
+      projects: ['demo-project'],
+      role: 'admin',
+    };
+  },
+  projectProvider: async (projectId) => {
+    // fetch project from your DB
+    return {
+      id: projectId,
+      name: 'Demo Project',
+      description: 'Demo for StreamBy integration',
+      rootFolders: [],
+      settings: { allowUpload: true }
+    };
+  }
+}));
+
+app.listen(3000);
+```
+
+---
+
+## 🧪 Testing
+
+```bash
+npm run test
+```
+
+Unit tests use [Vitest](https://vitest.dev) and [Supertest](https://www.npmjs.com/package/supertest).
+
+---
+
+## 📁 Features
+
+- 📂 Multi-project access control
+- 🔐 Project-aware file uploads & listings
+- 🧹 Modular adapters per storage provider
+- 🧰 Built-in testability with mock auth & storage
+- ✨ Simple to extend for custom business logic
+
+---
+
+## 🗺️ API Endpoints
+
+Here's a summary of the key API endpoints provided by `@streamby/core`:
+
+### `GET /streamby/projects`
+
+Lists all projects accessible by the authenticated user.
+
+**Query Parameters:**
+- `archived`: (Optional) Filter projects by their archived status.
+  - `true`: Returns only archived projects.
+  - `false`: Returns only unarchived projects.
+  - (Omitted): Returns all projects (both archived and unarchived).
+
+**Example Response:**
+```json
+{
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": false
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": true
+    }
+  ]
+}
+```
+
+### `PATCH /streamby/projects/:id/archive`
+
+Archives a specific project. After archiving, it returns the complete list of projects for the user, including the updated project.
+
+**Example Response:**
+```json
+{
+  "success": true,
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": true
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": false
+    }
+  ]
+}
+```
+
+### `PATCH /streamby/projects/:id/unarchive`
+
+Unarchives a specific project. After unarchiving, it returns the complete list of projects for the user, including the updated project.
+
+**Example Response:**
+```json
+{
+  "success": true,
+  "projects": [
+    {
+      "id": "project1_id",
+      "dbType": "nosql",
+      "name": "My NoSQL Project",
+      "image": "url_to_image",
+      "archived": false
+    },
+    {
+      "id": "project2_id",
+      "dbType": "sql",
+      "name": "My SQL Project",
+      "image": "url_to_image",
+      "archived": false
+    }
+  ]
+}
+```
+
+---
+
+## 🚣 Roadmap
+
+- [ ] Support for Google Cloud Storage
+- [ ] CLI tool for uploading files
+- [ ] Role-based access control middleware
+- [ ] Plugin system for extended routes
+- [ ] Streaming support (HLS, audio, etc.)
+
+---
+
+## 🧑‍💻 Maintained by
+
+**TerminalCore Labs** – part of [Nhexa Entertainment](https://nhexa.cl)  
+Developed as open-source infrastructure for creative and media-oriented apps.
+
+Visit us [here](https://terminalcore.cl)
+
+---
+
+## 📟 License
+
+[MIT](./LICENSE)
+

package/dist/adapters/database/connectionManager.js

@@ -44,8 +44,9 @@ exports.getConnection = getConnection;
 const ensureTablesExist = async (pool) => {
     try {
         await pool.query(`
+      CREATE SCHEMA IF NOT EXISTS streamby;
       CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
-      CREATE TABLE IF NOT EXISTS projects (
+      CREATE TABLE IF NOT EXISTS streamby.projects (
         id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
         name VARCHAR(255) NOT NULL,
         description TEXT,
@@ -57,21 +58,21 @@ const ensureTablesExist = async (pool) => {
         console.log('✅ "projects" table ensured to exist.');
         // Ensure dbType column exists and is correctly configured
         await pool.query(`
-      ALTER TABLE projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50);
+      ALTER TABLE streamby.projects ADD COLUMN IF NOT EXISTS "dbType" VARCHAR(50);
     `);
         await pool.query(`
-      UPDATE projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
+      UPDATE streamby.projects SET "dbType" = 'nosql' WHERE "dbType" IS NULL;
     `);
         await pool.query(`
-      ALTER TABLE projects ALTER COLUMN "dbType" SET NOT NULL;
+      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET NOT NULL;
     `);
         await pool.query(`
-      ALTER TABLE projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
+      ALTER TABLE streamby.projects ALTER COLUMN "dbType" SET DEFAULT 'nosql';
     `);
         await pool.query(`
-      CREATE TABLE IF NOT EXISTS exports (
+      CREATE TABLE IF NOT EXISTS streamby.exports (
         id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        "projectId" UUID NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
         status VARCHAR(50) NOT NULL DEFAULT 'pending',
         "filePath" TEXT,
         "createdAt" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
@@ -80,9 +81,9 @@ const ensureTablesExist = async (pool) => {
     `);
         console.log('✅ "exports" table ensured to exist.');
         await pool.query(`
-      CREATE TABLE IF NOT EXISTS project_members (
+      CREATE TABLE IF NOT EXISTS streamby.project_members (
         id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
-        "projectId" UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+        "projectId" UUID NOT NULL REFERENCES streamby.projects(id) ON DELETE CASCADE,
         "userId" VARCHAR(255) NOT NULL,
         role VARCHAR(255) NOT NULL DEFAULT 'member',
         archived BOOLEAN NOT NULL DEFAULT FALSE,

package/dist/adapters/database/sql.d.ts

@@ -10,7 +10,7 @@ export declare const createSQLRawExportTable: (connection: Pool, projectId: stri
 }>;
 export declare const sqlAdapter: {
     find: (connection: Pool, tableName: string, filter: any) => Promise<any[]>;
-    findOne: (connection: Pool, tableName: string, filter: any) => Promise<any | null>;
+    findOne: (connection: Pool, tableName: string, filter: any, schema?: string) => Promise<any | null>;
     create: (connection: Pool, tableName: string, data: any) => Promise<any>;
     update: (connection: Pool, tableName: string, filter: any, data: any) => Promise<any | null>;
     delete: (connection: Pool, tableName: string, filter: any) => Promise<number>;

package/dist/adapters/database/sql.js

@@ -55,11 +55,12 @@ exports.sqlAdapter = {
         const result = await connection.query(query, values);
         return result.rows;
     },
-    findOne: async (connection, tableName, filter) => {
+    findOne: async (connection, tableName, filter, schema) => {
         const keys = Object.keys(filter);
         const values = Object.values(filter);
-        const where = keys.map((key, i) => `"${key}" = $${i + 1}`).join(' AND ');
-        const result = await connection.query(`SELECT * FROM "${tableName}" WHERE ${where} LIMIT 1`, values);
+        const where = keys.map((key, i) => `"${key}" = ${i + 1}`).join(' AND ');
+        const fullTableName = schema ? `"${schema}"."${tableName}"` : `"${tableName}"`;
+        const result = await connection.query(`SELECT * FROM ${fullTableName} WHERE ${where} LIMIT 1`, values);
         return result.rows[0] || null;
     },
     create: async (connection, tableName, data) => {

package/dist/config/types.d.ts

@@ -0,0 +1,18 @@
+import { Pool } from 'pg';
+import { MongoClient } from 'mongodb';
+export interface SetupStreambyPgOptions {
+    pool: Pool;
+    schema?: string;
+    reset?: boolean;
+    allowResetInProd?: boolean;
+}
+export interface SetupStreambyMongoOptions {
+    client: MongoClient;
+    dbName?: string;
+}
+export interface SetupResult {
+    didCreateSchema: boolean;
+    didCreateTables: boolean;
+    didReset: boolean;
+    errors: string[];
+}

package/dist/config/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/middleware/routes/project.js

@@ -58,7 +58,7 @@ function projectRouter(config) {
                 return res.status(500).json({ message: 'Main database not configured' });
             }
             const userDbType = mainDb.type;
-            const User = (0, manager_1.getModel)('users', userDbType);
+            const User = (0, manager_1.getModel)('users', userDbType, 'accounts');
             const user = await User.findOne({ _id: auth.userId });
             if (!user) {
                 return res.status(404).json({ message: 'User not found' });
@@ -80,6 +80,7 @@ function projectRouter(config) {
             res.status(200).json({ success: true, projects: projects, projectId: newProject._id || newProject.id, message: 'Project created successfully' });
         }
         catch (err) {
+            console.error('Error creating project:', err);
             res.status(500).json({ message: 'Failed to create project', details: err.message });
         }
     });
@@ -248,7 +249,7 @@ function projectRouter(config) {
                 return res.status(500).json({ message: 'Main database not configured' });
             }
             const userDbType = mainDb.type;
-            const User = (0, manager_1.getModel)('users', userDbType);
+            const User = (0, manager_1.getModel)('users', userDbType, 'accounts');
             const membersWithUsernames = await Promise.all(project.members.map(async (member) => {
                 const user = await User.findOne({ _id: member.userId });
                 return {

package/dist/models/Model.d.ts

@@ -2,7 +2,10 @@ import { Document } from 'mongodb';
 export declare class Model<T extends Document> {
     private connectionIds;
     private tableName;
-    constructor(connectionIds: string[], tableName: string);
+    private schema?;
+    constructor(connectionIds: string[], tableName: string, schema?: string);
+    getConnectionIds(): string[];
+    getTableName(): string;
     useDbType(dbType: string): Model<T>;
     find(filter: any): Promise<T[]>;
     private transformResult;

package/dist/models/Model.js

@@ -6,9 +6,17 @@ const mongodb_1 = require("mongodb");
 const sql_1 = require("../adapters/database/sql");
 const nosql_1 = require("../adapters/database/nosql");
 class Model {
-    constructor(connectionIds, tableName) {
+    constructor(connectionIds, tableName, schema) {
         this.connectionIds = connectionIds;
         this.tableName = tableName;
+        this.schema = schema;
+    }
+    // Add these getter methods
+    getConnectionIds() {
+        return this.connectionIds;
+    }
+    getTableName() {
+        return this.tableName;
     }
     useDbType(dbType) {
         const filteredConnectionIds = this.connectionIds.filter(id => {
@@ -34,11 +42,11 @@ class Model {
                 if (this.tableName === 'projects' && processedFilter.members && processedFilter.members.$elemMatch) {
                     // Handle members filter for SQL projects
                     const userId = processedFilter.members.$elemMatch.userId;
-                    const query = `
-            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
-            FROM "projects" p
-            JOIN "project_members" pm ON p.id = pm."projectId"
-            WHERE pm."userId" = $1
+                    const query = `
+            SELECT p.*, pm."userId" as memberUserId, pm.archived as memberArchived
+            FROM "projects" p
+            JOIN "project_members" pm ON p.id = pm."projectId"
+            WHERE pm."userId" = $1
           `;
                     const result = await connection.query(query, [userId]);
                     sqlResults = result.rows.map(row => ({
@@ -96,7 +104,14 @@ class Model {
                     processedFilter.id = processedFilter._id;
                     delete processedFilter._id;
                 }
-                const result = await sql_1.sqlAdapter.findOne(connection, this.tableName, processedFilter);
+                // Special handling for 'users' table with raw query
+                if (this.tableName === 'users' && processedFilter.id) {
+                    const schema = this.schema || 'public'; // Default to 'public' if schema not provided
+                    const query = `SELECT * FROM "${schema}"."${this.tableName}" WHERE "id" = $1::uuid LIMIT 1`;
+                    const result = await connection.query(query, [processedFilter.id]);
+                    return result.rows[0] || null;
+                }
+                const result = await sql_1.sqlAdapter.findOne(connection, this.tableName, processedFilter, this.schema); // Pass this.schema
                 if (result) {
                     const transformedResult = this.transformResult(result);
                     if (this.tableName === 'projects') {

package/dist/models/registry.d.ts

@@ -1,3 +1,3 @@
 import { Model } from './Model';
-export declare const defineModel: (name: string, connectionIds: string[], tableName: string) => void;
-export declare const getModel: (name: string, dbType?: string) => Model<any>;
+export declare const defineModel: (name: string, connectionIds: string[], tableName: string, schema?: string) => void;
+export declare const getModel: (name: string, dbType?: string, schema?: string) => Model<any>;

package/dist/models/registry.js

@@ -3,15 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getModel = exports.defineModel = void 0;
 const Model_1 = require("./Model");
 const models = {};
-const defineModel = (name, connectionIds, tableName) => {
-    models[name] = new Model_1.Model(connectionIds, tableName);
+const defineModel = (name, connectionIds, tableName, schema) => {
+    models[name] = new Model_1.Model(connectionIds, tableName, schema);
 };
 exports.defineModel = defineModel;
-const getModel = (name, dbType) => {
+const getModel = (name, dbType, schema) => {
     const model = models[name];
     if (!model) {
         throw new Error(`Model ${name} not defined.`);
     }
+    // If a schema is provided, create a new Model instance with the specified schema
+    if (schema) {
+        return new Model_1.Model(model.getConnectionIds(), model.getTableName(), schema); // Use getters
+    }
     if (dbType) {
         return model.useDbType(dbType);
     }

package/dist/mongo/setup.d.ts

@@ -0,0 +1,2 @@
+import { SetupStreambyMongoOptions } from '../config/types';
+export declare function setupStreambyMongo({ client, dbName, }: SetupStreambyMongoOptions): Promise<void>;

package/dist/mongo/setup.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupStreambyMongo = setupStreambyMongo;
+async function setupStreambyMongo({ client, dbName = 'streamby', }) {
+    const db = client.db(dbName);
+    // Create collections if they don't exist. createCollection is idempotent.
+    // It will not recreate the collection if it already exists.
+    await db.createCollection('projects');
+    await db.createCollection('assets');
+    // Create indexes idempotently. createIndex will not recreate if an index
+    // with the same key and options already exists.
+    // projects collection indexes
+    // { name: 1 } (unique opcional si aplica) - starting with non-unique as it's safer
+    await db.collection('projects').createIndex({ name: 1 });
+    // assets collection indexes
+    await db.collection('assets').createIndex({ projectId: 1 });
+    await db.collection('assets').createIndex({ path: 1 });
+    console.log(`MongoDB setup complete for database: ${dbName}`);
+}

package/dist/pg/setup.d.ts

@@ -0,0 +1,2 @@
+import { SetupStreambyPgOptions, SetupResult } from '../config/types';
+export declare function setupStreambyPg({ pool, schema, reset, allowResetInProd, }: SetupStreambyPgOptions): Promise<SetupResult>;

package/dist/pg/setup.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupStreambyPg = setupStreambyPg;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+async function setupStreambyPg({ pool, schema = 'streamby', reset = false, allowResetInProd = false, // New parameter
+ }) {
+    const client = await pool.connect();
+    const lockKey = `streamby:setup:${schema}`;
+    const lockHash = `hashtext('${lockKey}')`;
+    const result = {
+        didCreateSchema: false,
+        didCreateTables: false,
+        didReset: false,
+        errors: [],
+    };
+    try {
+        // Production safety check
+        if (process.env.NODE_ENV === 'production' && reset && !allowResetInProd) {
+            const errorMessage = `Attempted to reset schema '${schema}' in production environment without explicit 'allowResetInProd' flag. Aborting to prevent data loss.`;
+            result.errors.push(errorMessage);
+            throw new Error(errorMessage);
+        }
+        const lockResult = await client.query(`SELECT pg_try_advisory_lock(${lockHash})::boolean AS locked;`);
+        if (!lockResult.rows[0].locked) {
+            const errorMessage = `Another setup process for schema '${schema}' is already running. Could not acquire advisory lock.`;
+            result.errors.push(errorMessage);
+            throw new Error(errorMessage);
+        }
+        await client.query('BEGIN;');
+        let fullSql = '';
+        // Read and append reset SQL if reset is true
+        if (reset) {
+            console.log(`[StreamByPgSetup] Resetting schema "${schema}"...`);
+            const resetSqlPath = (0, node_path_1.join)(__dirname, '../../sql/reset.sql');
+            const resetSql = await node_fs_1.promises.readFile(resetSqlPath, 'utf8');
+            fullSql += resetSql;
+            result.didReset = true;
+            result.didCreateSchema = true; // Schema is recreated during reset
+        }
+        else {
+            console.log(`[StreamByPgSetup] Ensuring schema "${schema}" exists...`);
+            // If not resetting, the CREATE SCHEMA IF NOT EXISTS in setup.sql will handle it.
+            // We can assume it will attempt to create if not exists.
+            result.didCreateSchema = true;
+        }
+        // Read and append setup SQL
+        console.log(`[StreamByPgSetup] Creating/updating tables and indexes in schema "${schema}"...`);
+        const setupSqlPath = (0, node_path_1.join)(__dirname, '../../sql/setup.sql');
+        const setupSql = await node_fs_1.promises.readFile(setupSqlPath, 'utf8');
+        fullSql += setupSql;
+        result.didCreateTables = true; // Assuming if setup.sql runs, tables are handled
+        // Replace {{SCHEMA}} token with the actual schema name, ensuring proper quoting
+        const finalSql = fullSql.replace(/{{SCHEMA}}/g, `"${schema}"`);
+        await client.query(finalSql);
+        await client.query('COMMIT;');
+        console.log(`[StreamByPgSetup] Schema setup for "${schema}" completed successfully.`);
+    }
+    catch (error) {
+        await client.query('ROLLBACK;');
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        result.errors.push(errorMessage);
+        console.error(`[StreamByPgSetup] Error during schema setup for "${schema}":`, error);
+        throw error; // Re-throw the error after logging and capturing
+    }
+    finally {
+        await client.query(`SELECT pg_advisory_unlock(${lockHash});`);
+        client.release();
+    }
+    return result;
+}

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "streamby-core",
-  "version": "0.23.5",
-  "description": "StreamBy middleware framework for media storage management",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest",
-    "dev": "ts-node-dev --respawn --clear dev.ts",
-    "prepublishOnly": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/GwerhDev/StreamBy-Package.git"
-  },
-  "keywords": [
-    "streamby",
-    "middleware",
-    "upload",
-    "storage",
-    "s3",
-    "express",
-    "typescript"
-  ],
-  "author": "TerminalCore Labs",
-  "license": "MIT",
-  "dependencies": {
-    "@aws-sdk/client-s3": "^3.528.0",
-    "@aws-sdk/s3-request-presigner": "^3.787.0",
-    "@prisma/client": "^6.12.0",
-    "bcrypt": "^5.1.1",
-    "dotenv": "^16.5.0",
-    "express": "^4.0.0",
-    "mongodb": "^6.17.0",
-    "mongoose": "^8.13.2",
-    "pg": "^8.16.3",
-    "prisma": "^6.12.0"
-  },
-  "devDependencies": {
-    "@types/bcrypt": "^5.0.2",
-    "@types/cors": "^2.8.18",
-    "@types/express": "^4.17.17",
-    "@types/mongodb": "^4.0.7",
-    "@types/node": "^22.15.21",
-    "@types/pg": "^8.15.4",
-    "@types/supertest": "^6.0.3",
-    "cors": "^2.8.5",
-    "supertest": "^7.1.4",
-    "ts-node-dev": "^2.0.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.1"
-  },
-  "peerDependencies": {
-    "express": "^4.0.0"
-  }
-}
+{
+  "name": "streamby-core",
+  "version": "0.24.1",
+  "description": "StreamBy middleware framework for media storage management",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest",
+    "dev": "ts-node-dev --respawn --clear dev.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GwerhDev/StreamBy-Package.git"
+  },
+  "keywords": [
+    "streamby",
+    "middleware",
+    "upload",
+    "storage",
+    "s3",
+    "express",
+    "typescript"
+  ],
+  "author": "TerminalCore Labs",
+  "license": "MIT",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.528.0",
+    "@aws-sdk/s3-request-presigner": "^3.787.0",
+    "@prisma/client": "^6.12.0",
+    "bcrypt": "^5.1.1",
+    "dotenv": "^16.5.0",
+    "express": "^4.0.0",
+    "mongodb": "^6.17.0",
+    "mongoose": "^8.13.2",
+    "pg": "^8.16.3",
+    "prisma": "^6.12.0"
+  },
+  "devDependencies": {
+    "@types/bcrypt": "^5.0.2",
+    "@types/cors": "^2.8.18",
+    "@types/express": "^4.17.17",
+    "@types/mongodb": "^4.0.7",
+    "@types/node": "^22.15.21",
+    "@types/pg": "^8.15.4",
+    "@types/supertest": "^6.0.3",
+    "cors": "^2.8.5",
+    "supertest": "^7.1.4",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1"
+  },
+  "peerDependencies": {
+    "express": "^4.0.0"
+  }
+}