streamby-core 0.17.0 → 0.19.0

package/dist/adapters/s3.js

@@ -1,82 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createS3Adapter = createS3Adapter;
+exports.S3Adapter = void 0;
 const client_s3_1 = require("@aws-sdk/client-s3");
 const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
-function createS3Adapter(config) {
-    const s3 = new client_s3_1.S3Client({
-        region: config.region,
-        credentials: {
-            accessKeyId: config.accessKeyId,
-            secretAccessKey: config.secretAccessKey,
-        },
-    });
-    return {
-        async getPresignedProjectImageUrl(projectId) {
-            const key = `${projectId}/project-image`;
-            const command = new client_s3_1.PutObjectCommand({
-                Bucket: config.bucket,
-                Key: key,
-                ContentType: 'image/*',
-            });
-            const url = await (0, s3_request_presigner_1.getSignedUrl)(s3, command, { expiresIn: 60 });
-            const publicUrl = `https://${config.bucket}.s3.${config.region}.amazonaws.com/${encodeURIComponent(key)}`;
-            return { url, publicUrl };
-        },
-        async deleteProjectImage(projectId) {
-            const key = `${projectId}/project-image`;
-            const command = new client_s3_1.DeleteObjectsCommand({
-                Bucket: config.bucket,
-                Delete: {
-                    Objects: [{ Key: key }],
-                },
-            });
-            await s3.send(command);
-        },
-        async getPresignedUrl(contentType, projectId) {
-            const key = `${projectId}/${contentType}/file-${Date.now()}`;
-            const command = new client_s3_1.PutObjectCommand({
-                Bucket: config.bucket,
-                Key: key,
-                ContentType: contentType,
-            });
-            const url = await (0, s3_request_presigner_1.getSignedUrl)(s3, command, { expiresIn: 60 });
-            const publicUrl = `https://${config.bucket}.s3.${config.region}.amazonaws.com/${encodeURIComponent(key)}`;
-            return { url, publicUrl };
-        },
-        async listFiles(projectId) {
-            const command = new client_s3_1.ListObjectsV2Command({
-                Bucket: config.bucket,
-                Prefix: `${projectId}/`,
-            });
-            const result = await s3.send(command);
-            return result.Contents || [];
-        },
-        async deleteProjectDirectory(projectId) {
-            const prefix = `${projectId}/`;
-            let continuationToken = undefined;
-            while (true) {
-                const listCommand = new client_s3_1.ListObjectsV2Command({
-                    Bucket: config.bucket,
-                    Prefix: prefix,
-                    ContinuationToken: continuationToken
-                });
-                const listedObjects = await s3.send(listCommand);
-                const contents = listedObjects.Contents || [];
-                if (contents.length > 0) {
-                    const objectsToDelete = contents.map((item) => ({
-                        Key: item.Key
-                    }));
-                    const deleteCommand = new client_s3_1.DeleteObjectsCommand({
-                        Bucket: config.bucket,
-                        Delete: { Objects: objectsToDelete },
-                    });
-                    await s3.send(deleteCommand);
-                }
-                if (!listedObjects.IsTruncated)
-                    break;
-                continuationToken = listedObjects.NextContinuationToken;
-            }
+class S3Adapter {
+    constructor(config) {
+        this.s3 = new client_s3_1.S3Client({
+            region: config.region,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            },
+        });
+        this.bucket = config.bucket;
+    }
+    async listFiles(projectId) {
+        const command = new client_s3_1.ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: `${projectId}/`,
+        });
+        const result = await this.s3.send(command);
+        return result.Contents || [];
+    }
+    async deleteProjectImage(projectId) {
+        const command = new client_s3_1.DeleteObjectCommand({
+            Bucket: this.bucket,
+            Key: `${projectId}/project-image`,
+        });
+        return await this.s3.send(command);
+    }
+    async deleteProjectDirectory(projectId) {
+        const listCommand = new client_s3_1.ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: `${projectId}/`,
+        });
+        const listedObjects = await this.s3.send(listCommand);
+        if (!listedObjects.Contents || listedObjects.Contents.length === 0) {
+            return;
         }
-    };
+        const deleteParams = {
+            Bucket: this.bucket,
+            Delete: { Objects: listedObjects.Contents.map(({ Key }) => ({ Key })) },
+        };
+        const deleteCommand = new client_s3_1.DeleteObjectCommand(deleteParams);
+        return await this.s3.send(deleteCommand);
+    }
+    async getPresignedUrl(contentType, projectId) {
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            Key: `${projectId}/${Date.now()}`,
+            ContentType: contentType,
+        });
+        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
+    }
+    async getPresignedProjectImageUrl(projectId) {
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            Key: `${projectId}/project-image`,
+            ContentType: 'image/jpeg',
+        });
+        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
+    }
 }
+exports.S3Adapter = S3Adapter;

package/dist/adapters/storage/gcs.js

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

package/dist/adapters/storage/local.js

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

package/dist/adapters/storage/s3.d.ts

@@ -0,0 +1,11 @@
+import { S3Config, StorageAdapter } from '../../types';
+export declare class S3Adapter implements StorageAdapter {
+    private s3;
+    private bucket;
+    constructor(config: S3Config);
+    listFiles(projectId: string): Promise<any[]>;
+    deleteProjectImage(projectId: string): Promise<any>;
+    deleteProjectDirectory(projectId: string): Promise<any>;
+    getPresignedUrl(contentType: string, projectId: string): Promise<any>;
+    getPresignedProjectImageUrl(projectId: string): Promise<any>;
+}

package/dist/adapters/storage/s3.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Adapter = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
+class S3Adapter {
+    constructor(config) {
+        this.s3 = new client_s3_1.S3Client({
+            region: config.region,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey,
+            },
+        });
+        this.bucket = config.bucket;
+    }
+    async listFiles(projectId) {
+        const command = new client_s3_1.ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: `${projectId}/`,
+        });
+        const result = await this.s3.send(command);
+        return result.Contents || [];
+    }
+    async deleteProjectImage(projectId) {
+        const command = new client_s3_1.DeleteObjectCommand({
+            Bucket: this.bucket,
+            Key: `${projectId}/project-image`,
+        });
+        return await this.s3.send(command);
+    }
+    async deleteProjectDirectory(projectId) {
+        const listCommand = new client_s3_1.ListObjectsV2Command({
+            Bucket: this.bucket,
+            Prefix: `${projectId}/`,
+        });
+        const listedObjects = await this.s3.send(listCommand);
+        if (!listedObjects.Contents || listedObjects.Contents.length === 0) {
+            return;
+        }
+        const deleteParams = {
+            Bucket: this.bucket,
+            Delete: { Objects: listedObjects.Contents.map(({ Key }) => ({ Key })) },
+        };
+        const deleteCommand = new client_s3_1.DeleteObjectCommand(deleteParams);
+        return await this.s3.send(deleteCommand);
+    }
+    async getPresignedUrl(contentType, projectId) {
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            Key: `${projectId}/${Date.now()}`,
+            ContentType: contentType,
+        });
+        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
+    }
+    async getPresignedProjectImageUrl(projectId) {
+        const command = new client_s3_1.PutObjectCommand({
+            Bucket: this.bucket,
+            Key: `${projectId}/project-image`,
+            ContentType: 'image/jpeg',
+        });
+        return await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn: 3600 });
+    }
+}
+exports.S3Adapter = S3Adapter;

package/dist/database/Model.d.ts

@@ -0,0 +1,11 @@
+import { Document } from 'mongodb';
+export declare class Model<T extends Document> {
+    private connectionId;
+    private tableName;
+    constructor(connectionId: string, tableName: string);
+    find(filter: any): Promise<T[]>;
+    findOne(filter: any): Promise<T | null>;
+    create(data: T): Promise<T>;
+    update(filter: any, data: Partial<T>): Promise<number>;
+    delete(filter: any): Promise<number>;
+}

package/dist/database/Model.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const connectionManager_1 = require("./connectionManager");
+const pg_1 = require("pg");
+const mongodb_1 = require("mongodb");
+class Model {
+    constructor(connectionId, tableName) {
+        this.connectionId = connectionId;
+        this.tableName = tableName;
+    }
+    async find(filter) {
+        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
+        if (connection instanceof pg_1.Pool) {
+            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 "${this.tableName}" WHERE ${where}`, values);
+            return result.rows;
+        }
+        else if (connection instanceof mongodb_1.MongoClient) {
+            const db = connection.db();
+            const result = await db.collection(this.tableName).find(filter).toArray();
+            return result;
+        }
+        return [];
+    }
+    async findOne(filter) {
+        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
+        if (connection instanceof pg_1.Pool) {
+            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 "${this.tableName}" WHERE ${where} LIMIT 1`, values);
+            return result.rows[0] || null;
+        }
+        else if (connection instanceof mongodb_1.MongoClient) {
+            const db = connection.db();
+            const result = await db.collection(this.tableName).findOne(filter);
+            return result;
+        }
+        return null;
+    }
+    async create(data) {
+        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
+        if (connection instanceof pg_1.Pool) {
+            const keys = Object.keys(data).join(', ');
+            const values = Object.values(data);
+            const placeholders = values.map((_, i) => `$${i + 1}`).join(', ');
+            const result = await connection.query(`INSERT INTO "${this.tableName}" (${keys}) VALUES (${placeholders}) RETURNING *`, values);
+            return result.rows[0];
+        }
+        else if (connection instanceof mongodb_1.MongoClient) {
+            const db = connection.db();
+            const result = await db.collection(this.tableName).insertOne(data);
+            return { ...data, _id: result.insertedId };
+        }
+        return data;
+    }
+    async update(filter, data) {
+        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
+        if (connection instanceof pg_1.Pool) {
+            const dataKeys = Object.keys(data);
+            const filterKeys = Object.keys(filter);
+            const values = [...Object.values(data), ...Object.values(filter)];
+            const setClause = dataKeys.map((key, i) => `"${key}" = $${i + 1}`).join(', ');
+            const whereClause = filterKeys.map((key, i) => `"${key}" = $${dataKeys.length + i + 1}`).join(' AND ');
+            const result = await connection.query(`UPDATE "${this.tableName}" SET ${setClause} WHERE ${whereClause}`, values);
+            return result.rowCount || 0;
+        }
+        else if (connection instanceof mongodb_1.MongoClient) {
+            const db = connection.db();
+            const result = await db.collection(this.tableName).updateMany(filter, { $set: data });
+            return result.modifiedCount;
+        }
+        return 0;
+    }
+    async delete(filter) {
+        const connection = (0, connectionManager_1.getConnection)(this.connectionId);
+        if (connection instanceof pg_1.Pool) {
+            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(`DELETE FROM "${this.tableName}" WHERE ${where}`, values);
+            return result.rowCount || 0;
+        }
+        else if (connection instanceof mongodb_1.MongoClient) {
+            const db = connection.db();
+            const result = await db.collection(this.tableName).deleteMany(filter);
+            return result.deletedCount;
+        }
+        return 0;
+    }
+}
+exports.Model = Model;

package/dist/database/connectionManager.d.ts

@@ -0,0 +1,5 @@
+import { Pool } from 'pg';
+import { MongoClient } from 'mongodb';
+import { DatabaseCredential } from '../types';
+export declare const initConnections: (configs: DatabaseCredential[]) => Promise<void>;
+export declare const getConnection: (id: string) => Pool | MongoClient;

package/dist/database/connectionManager.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConnection = exports.initConnections = void 0;
+const pg_1 = require("pg");
+const mongodb_1 = require("mongodb");
+const clients = {};
+const initConnections = async (configs) => {
+    for (const config of configs) {
+        if (!config.connectionString) {
+            throw new Error(`Connection string not provided for database config with id ${config.id}`);
+        }
+        if (config.type === 'sql') {
+            const pool = new pg_1.Pool({ connectionString: config.connectionString });
+            await pool.connect();
+            clients[config.id] = pool;
+        }
+        else if (config.type === 'nosql') {
+            const client = new mongodb_1.MongoClient(config.connectionString);
+            await client.connect();
+            clients[config.id] = client;
+        }
+    }
+};
+exports.initConnections = initConnections;
+const getConnection = (id) => {
+    const client = clients[id];
+    if (!client) {
+        throw new Error(`Connection with id ${id} not found.`);
+    }
+    return client;
+};
+exports.getConnection = getConnection;

package/dist/database/index.d.ts

@@ -0,0 +1,3 @@
+export * from './connectionManager';
+export * from './Model';
+export * from './modelRegistry';

package/dist/database/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./connectionManager"), exports);
+__exportStar(require("./Model"), exports);
+__exportStar(require("./modelRegistry"), exports);

package/dist/database/model.d.ts

@@ -0,0 +1,20 @@
+export interface BaseModel {
+    id?: string;
+}
+export interface ModelDefinition<T extends BaseModel> {
+    name: string;
+    connectionName: string;
+}
+export interface QueryOptions {
+    filter?: Record<string, any>;
+    limit?: number;
+    offset?: number;
+    sort?: Record<string, 1 | -1>;
+}
+export interface ModelOperations<T extends BaseModel> {
+    find(options?: QueryOptions): Promise<T[]>;
+    findById(id: string): Promise<T | null>;
+    create(data: Omit<T, 'id'>): Promise<T>;
+    update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null>;
+    delete(id: string): Promise<boolean>;
+}

package/dist/database/model.js

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

package/dist/database/modelManager.d.ts

@@ -0,0 +1,8 @@
+import { BaseModel, ModelDefinition, ModelOperations } from './model';
+declare class ModelManager {
+    private models;
+    registerModel<T extends BaseModel>(definition: ModelDefinition<T>): void;
+    getModel<T extends BaseModel>(name: string): ModelOperations<T>;
+}
+export declare const modelManager: ModelManager;
+export {};

package/dist/database/modelManager.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelManager = void 0;
+const connectionManager_1 = require("./connectionManager");
+const sqlAdapter_1 = require("./sqlAdapter");
+const mongoAdapter_1 = require("./mongoAdapter");
+const mongodb_1 = require("mongodb");
+class ModelManager {
+    constructor() {
+        this.models = new Map();
+    }
+    registerModel(definition) {
+        const client = connectionManager_1.connectionManager.getClient(definition.connectionName);
+        if (!client) {
+            throw new Error(`Connection '${definition.connectionName}' not found for model '${definition.name}'`);
+        }
+        let adapter;
+        if (client instanceof mongodb_1.Pool) {
+            adapter = new sqlAdapter_1.SqlAdapter(client, definition.name.toLowerCase() + 's'); // Assuming table name is plural of model name
+        }
+        else if (client instanceof mongodb_1.MongoClient) {
+            adapter = new mongoAdapter_1.MongoAdapter(client, definition.name.toLowerCase() + 's'); // Assuming collection name is plural of model name
+        }
+        else {
+            throw new Error(`Unsupported client type for connection '${definition.connectionName}'`);
+        }
+        this.models.set(definition.name, adapter);
+        console.log(`Model '${definition.name}' registered with connection '${definition.connectionName}'`);
+    }
+    getModel(name) {
+        const model = this.models.get(name);
+        if (!model) {
+            throw new Error(`Model '${name}' not found. Make sure it is registered.`);
+        }
+        return model;
+    }
+}
+exports.modelManager = new ModelManager();

package/dist/database/modelRegistry.d.ts

@@ -0,0 +1,3 @@
+import { Model } from './Model';
+export declare const defineModel: (name: string, connectionId: string, tableName: string) => void;
+export declare const getModel: (name: string) => Model<any>;

package/dist/database/modelRegistry.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = exports.defineModel = void 0;
+const Model_1 = require("./Model");
+const models = {};
+const defineModel = (name, connectionId, tableName) => {
+    models[name] = new Model_1.Model(connectionId, tableName);
+};
+exports.defineModel = defineModel;
+const getModel = (name) => {
+    const model = models[name];
+    if (!model) {
+        throw new Error(`Model ${name} not defined.`);
+    }
+    return model;
+};
+exports.getModel = getModel;

package/dist/database/mongoAdapter.d.ts

@@ -0,0 +1,11 @@
+import { MongoClient } from 'mongodb';
+import { BaseModel, ModelOperations, QueryOptions } from './model';
+export declare class MongoAdapter<T extends BaseModel> implements ModelOperations<T> {
+    private collection;
+    constructor(client: MongoClient, collectionName: string);
+    find(options?: QueryOptions): Promise<T[]>;
+    findById(id: string): Promise<T | null>;
+    create(data: Omit<T, 'id'>): Promise<T>;
+    update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null>;
+    delete(id: string): Promise<boolean>;
+}

package/dist/database/mongoAdapter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoAdapter = void 0;
+const mongodb_1 = require("mongodb");
+class MongoAdapter {
+    constructor(client, collectionName) {
+        // Assuming a default database name for now, or it could be passed in config
+        const db = client.db();
+        this.collection = db.collection(collectionName);
+    }
+    async find(options) {
+        let cursor = this.collection.find(options?.filter || {});
+        if (options?.sort) {
+            cursor = cursor.sort(options.sort);
+        }
+        if (options?.limit) {
+            cursor = cursor.limit(options.limit);
+        }
+        if (options?.offset) {
+            cursor = cursor.skip(options.offset);
+        }
+        const result = await cursor.toArray();
+        return result.map(doc => ({ ...doc, id: doc._id?.toString() }));
+    }
+    async findById(id) {
+        const doc = await this.collection.findOne({ _id: new mongodb_1.ObjectId(id) });
+        return doc ? { ...doc, id: doc._id?.toString() } : null;
+    }
+    async create(data) {
+        const result = await this.collection.insertOne(data);
+        return { ...data, id: result.insertedId.toString() };
+    }
+    async update(id, data) {
+        const result = await this.collection.findOneAndUpdate({ _id: new mongodb_1.ObjectId(id) }, { $set: data }, { returnDocument: 'after' });
+        return result.value ? { ...result.value, id: result.value._id?.toString() } : null;
+    }
+    async delete(id) {
+        const result = await this.collection.deleteOne({ _id: new mongodb_1.ObjectId(id) });
+        return result.deletedCount > 0;
+    }
+}
+exports.MongoAdapter = MongoAdapter;

package/dist/database/sqlAdapter.d.ts

@@ -0,0 +1,12 @@
+import { Pool } from 'pg';
+import { BaseModel, ModelOperations, QueryOptions } from './model';
+export declare class SqlAdapter<T extends BaseModel> implements ModelOperations<T> {
+    private client;
+    private tableName;
+    constructor(client: Pool, tableName: string);
+    find(options?: QueryOptions): Promise<T[]>;
+    findById(id: string): Promise<T | null>;
+    create(data: Omit<T, 'id'>): Promise<T>;
+    update(id: string, data: Partial<Omit<T, 'id'>>): Promise<T | null>;
+    delete(id: string): Promise<boolean>;
+}

package/dist/database/sqlAdapter.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlAdapter = void 0;
+class SqlAdapter {
+    constructor(client, tableName) {
+        this.client = client;
+        this.tableName = tableName;
+    }
+    async find(options) {
+        let query = `SELECT * FROM ${this.tableName}`;
+        const values = [];
+        const conditions = [];
+        let paramIndex = 1;
+        if (options?.filter) {
+            for (const key in options.filter) {
+                conditions.push(`${key} = $${paramIndex++}`);
+                values.push(options.filter[key]);
+            }
+        }
+        if (conditions.length > 0) {
+            query += ` WHERE ${conditions.join(' AND ')}`;
+        }
+        if (options?.sort) {
+            const sortKeys = Object.keys(options.sort);
+            if (sortKeys.length > 0) {
+                const orderBy = sortKeys.map(key => `${key} ${options.sort[key] === 1 ? 'ASC' : 'DESC'}`).join(', ');
+                query += ` ORDER BY ${orderBy}`;
+            }
+        }
+        if (options?.limit) {
+            query += ` LIMIT $${paramIndex++}`;
+            values.push(options.limit);
+        }
+        if (options?.offset) {
+            query += ` OFFSET $${paramIndex++}`;
+            values.push(options.offset);
+        }
+        const result = await this.client.query(query, values);
+        return result.rows;
+    }
+    async findById(id) {
+        const query = `SELECT * FROM ${this.tableName} WHERE id = $1`;
+        const result = await this.client.query(query, [id]);
+        return result.rows[0] || null;
+    }
+    async create(data) {
+        const keys = Object.keys(data);
+        const values = Object.values(data);
+        const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
+        const query = `INSERT INTO ${this.tableName} (${keys.join(', ')}) VALUES (${placeholders}) RETURNING *`;
+        const result = await this.client.query(query, values);
+        return result.rows[0];
+    }
+    async update(id, data) {
+        const keys = Object.keys(data);
+        const values = Object.values(data);
+        const setClauses = keys.map((key, i) => `${key} = $${i + 1}`).join(', ');
+        const query = `UPDATE ${this.tableName} SET ${setClauses} WHERE id = $${keys.length + 1} RETURNING *`;
+        const result = await this.client.query(query, [...values, id]);
+        return result.rows[0] || null;
+    }
+    async delete(id) {
+        const query = `DELETE FROM ${this.tableName} WHERE id = $1`;
+        const result = await this.client.query(query, [id]);
+        return result.rowCount > 0;
+    }
+}
+exports.SqlAdapter = SqlAdapter;