@smuzi/db-postgres 0.0.2 → 0.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smuzi/db-postgres",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "PostgreSQL driver for @smuzi/database",
   "type": "module",
   "types": "./build/index.d.ts",
@@ -16,8 +16,8 @@
     "access": "public"
   },
   "files": [
-    "./src",
-    "./build"
+    "build/**/*.js",
+    "build/**/*.d.ts"
   ],
   "exports": {
     "./package.json": "./package.json",
@@ -34,14 +34,14 @@
     "#lib/*": "./src/*"
   },
   "dependencies": {
-    "@smuzi/database": "0.0.2",
-    "@smuzi/std": "0.2.6",
-    "@smuzi/schema": "0.0.4",
+    "@smuzi/database": "0.0.5",
+    "@smuzi/std": "0.2.8",
+    "@smuzi/schema": "0.0.7",
     "pg": "^8.16.3"
   },
   "devDependencies": {
-    "@smuzi/faker": "0.0.5",
-    "@smuzi/tests": "0.0.3",
+    "@smuzi/faker": "0.0.6",
+    "@smuzi/tests": "0.0.5",
     "@types/node": "^22.15.21",
     "@types/pg": "^8.11.10",
     "typescript": "^7.0.2"
@@ -49,5 +49,6 @@
   "scripts": {
     "test": "tsx  --env-file=.env tests/index.ts",
     "build": "tsc --project tsconfig.build.json"
-  }
+  },
+  "main": "./build/index.js"
 }

package/src/entityRepository.ts

@@ -1,11 +0,0 @@
-import {TDatabaseClient} from "@smuzi/database";
-import {Option} from "@smuzi/std";
-
-export const buildPostgresEntityRepository = (client: TDatabaseClient)  => <Entity>(table: string) => {
-    return {
-        async find(id: number, { columns = ['*'], idColumn = 'id'}) {
-            return (await client.query(`SELECT ${columns.join(',')} FROM ${table} where ${idColumn} = $1`, [id]))
-                .mapOk(res => res.rows.get(0) as Option<Entity>);
-        },
-    }
-}

package/src/index.ts

@@ -1,160 +0,0 @@
-import { Pool } from 'pg'
-import {
-    preparedSqlFromObjectToArrayParams, TableRows,
-    TDatabaseClient, TInsertManyRowResult, TInsertRow, TInsertRowResult, DBQueryError,
-    TQueryParams,
-    TQueryResult
-} from "@smuzi/database";
-import {
-    isEmpty,
-    asArray,
-    asObject, dump,
-    Err,
-    isArray, isOption,
-    None,
-    Ok, Option,
-    OptionFromNullable,
-    RecordFromKeys, Result,
-    Simplify,
-    Some, StdList, StdRecord
-} from "@smuzi/std";
-import {SchemaObject} from "@smuzi/schema";
-export * from "./migrationsLogRepository.js"
-export * from "./entityRepository.js"
-
-export type Config = {
-    user: string,
-    password: string,
-    host: string,
-    port: number,
-    database: string,
-}
-
-
-
-
-export class PostgresClient implements TDatabaseClient {
-    readonly #pool: Pool;
-
-    constructor(private readonly config: Config) {
-         this.#pool = new Pool(config)
-
-         this.#pool.on('error', (err, config) => {
-            console.error('Unexpected error on idle client', err)
-            process.exit(-1)
-        })
-
-    }
-
-    async query<S extends SchemaObject>( sql: string, params: TQueryParams = [], schema: Option<S> = None()): Promise<TQueryResult<S>> {
-        let preparedSql = sql;
-        let preparedParams: unknown[] = asArray(params) ? params : [];
-
-        if (asObject(params)) {
-            const preparedRes = preparedSqlFromObjectToArrayParams(preparedSql, params).unwrap();
-            preparedSql = preparedRes.sql;
-            preparedParams = preparedRes.params;
-        }
-
-        try {
-            const res = await this.#pool.query({
-                    text: preparedSql,
-                    values: preparedParams,
-                },
-            );
-
-            return Ok({
-                rows: new TableRows(schema, res.rows),
-                rowCount: OptionFromNullable(res.rowCount),
-            })
-        } catch (err) {
-            return Err(new DBQueryError({
-                sql: preparedSql.substring(0, 200) + (preparedSql.length > 200 ? " ..." : ""),
-                message: err.message,
-                code: OptionFromNullable(err.code),
-                detail: OptionFromNullable(err.detail),
-                table: OptionFromNullable(err.table),
-            }));
-        }
-    }
-
-    async insertRow<S extends SchemaObject<any>, const RC extends string[]>(
-        table: string,
-        schema: S,
-        row: TInsertRow<S>,
-        returningColumns: RC = Array<string>() as RC
-    ): Promise<TInsertRowResult<S, RC>> {
-        //TODO: protected for injections
-        const columns = Object.keys(row);
-        const values = Object.values(row).map(val => isOption(val) ? val.someOr(null) : val);
-        const placeholders = values.map((_, index) => `$${index + 1}`).join(', ');
-
-        let sql = `INSERT INTO ${table} (${columns}) VALUES (${placeholders})`;
-        if (!isEmpty(returningColumns)) sql += ` RETURNING ${returningColumns.join(',')}` ;
-
-        return (await this.query(sql, values, Some(schema))).mapOk(res => res.rows.get(0)) as TInsertRowResult<S, RC>;
-            
-    }
-
-    async insertManyRows<S extends SchemaObject<any>, const RC extends string[]>(
-        table: string,
-        schema: S,
-        rows: TInsertRow<S>[],
-        returningColumns: RC = Array<string>() as RC
-    ): Promise<TInsertManyRowResult<S, RC>> {
-        if (rows.length === 0) return Ok(new TableRows(Some(schema), [])) as any;
-
-        //TODO: protected for injections
-
-        const columns = Object.keys(rows[0]);
-        const values: any[] = [];
-        const placeholders = rows.map((row, rowIndex) => {
-            return `(${columns.map((_, colIndex) => {
-                const placeholderIndex = rowIndex * columns.length + colIndex + 1;
-                return `$${placeholderIndex}`;
-            }).join(', ')})`;
-        }).join(', ');
-
-        rows.forEach(row => values.push(...Object.values(row).map(val => isOption(val) ? val.someOr(null) : val)));
-
-        return (await this.query(`INSERT INTO ${table} (${columns.join(', ')}) VALUES ${placeholders} RETURNING ${returningColumns.join(',')}`, values, Some(schema))).mapOk(result => result.rows) as any;
-    }
-
-    async updateRowById<S extends SchemaObject<any>>(
-        table: string,
-        schema: S,
-        id: number | string,
-        row: Partial<TInsertRow<S>>,
-        idColumn: string = 'id'
-    ): Promise<TQueryResult<S>>
-    {
-        //TODO: protected for injections
-        return await this.updateManyRows(table, row, `${idColumn} = ${id}`);
-    }
-
-    async updateManyRows<S extends SchemaObject<any>>(table: string, values: Partial<TInsertRow<S>>, where): Promise<TQueryResult<S>>
-    {
-        //TODO: protected for injections
-        const entries = Object.entries(values);
-
-        const setClause = entries
-            .map(([key], i) => `${key} = $${i + 1}`)
-            .join(", ");
-
-        const sql = `UPDATE ${table} SET ${setClause} WHERE ${where};`;
-
-        const params = entries.map(([, val]) => val);
-
-        return (await this.query(sql, params));
-    }
-
-}
-
-
-
-export function postgresClient(config: Config): TDatabaseClient {
-    return new PostgresClient(config);
-}
-
-
-

package/src/migrationsLogRepository.ts

@@ -1,69 +0,0 @@
-import {isEmpty, None, Option, Some} from "@smuzi/std";
-import {
-    migrationLogRowSchema,
-    TDatabaseClient,
-    TMigrationLogAction,
-    TMigrationLogRowSchema,
-    TMigrationsLogRepository
-} from "@smuzi/database";
-
-const table = 'migrations_log';
-
-export const buildPostgresMigrationsLogRepository = (client: TDatabaseClient): TMigrationsLogRepository  => {
-    return {
-        getTable: () => table,
-        createTableIfNotExists()  {
-            return client.query(`CREATE TABLE IF NOT EXISTS ${table} (
-            id SERIAL PRIMARY KEY,
-            name VARCHAR(255) NOT NULL ,
-            branch INTEGER NOT NULL,
-            action VARCHAR(20),
-            sql_source TEXT  NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-            );
-
-            CREATE INDEX IF NOT EXISTS idx_branch_name_created ON ${table} (branch, name, created_at DESC);
-`)
-        },
-        listRuned() {
-            return client.query<TMigrationLogRowSchema>(`SELECT * FROM ( SELECT DISTINCT ON (name) * FROM ${table} ORDER BY name, created_at DESC ) last_records WHERE action = '${TMigrationLogAction.up}'`);
-        },
-        listRunedByBranch(branch: number) {
-            return client.query<TMigrationLogRowSchema>(`SELECT * FROM ( SELECT DISTINCT ON (name) * FROM ${table} WHERE branch = ${branch} ORDER BY name, created_at DESC ) last_records WHERE action = '${TMigrationLogAction.up}'`);
-        },
-        async getLastBranch(): Promise<Option<number>> {
-            const res = (await client.query(`SELECT MAX(branch) as last_branch FROM ${table}`)).unwrap();
-            if (res.rowCount.isZero()) return None();
-
-            return res.rows.get(0).unwrap().get("last_branch");
-        },
-        create(row) {
-            return client.insertRow(table, migrationLogRowSchema, row);
-        },
-        async migrationLastAction(name: string) {
-            const res = (await client.query(`SELECT action FROM ${table} WHERE name = $1 ORDER BY created_at DESC LIMIT 1`, [name])).unwrap();
-
-            if (res.rowCount.isZero()) return None();
-            
-            return res.rows.get(0).unwrap().get("action");
-        },
-        async migrationWillBeRuned(name: string)
-        {
-            const lastAction = await this.migrationLastAction(name);
-
-            return lastAction.match({
-                Some: (v) => v === TMigrationLogAction.up,
-                None: () => false,
-            })
-        },
-        async freshSchema() {
-            return client.query(`DO $$ DECLARE
-    r RECORD;
-BEGIN
-    FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = 'public') LOOP
-        EXECUTE 'DROP TABLE IF EXISTS public.' || quote_ident(r.tablename) || ' CASCADE';
-    END LOOP;
-END $$;`);
-        }
-    }
-}