@smuzi/database 0.0.12 → 0.0.14

package/build/migration.d.ts

@@ -1,17 +1,14 @@
-import { TInsertRow, TInsertRowResult, TQueryResult } from "./types.js";
+import { TInsertRowResult, TQueryResult } from "./types.js";
 import { Option } from "@smuzi/std";
-import { SchemaObject } from "@smuzi/schema";
-export declare const migrationLogRowSchema: SchemaObject<{
-    name: import("@smuzi/schema").SchemaString;
-    branch: import("@smuzi/schema").SchemaNumber;
-    action: import("@smuzi/schema").SchemaString;
-    sql_source: import("@smuzi/schema").SchemaString;
-    created_at: import("@smuzi/schema").SchemaNativeDate<{
-        msg: string;
-    }>;
-}>;
-export type TMigrationLogRowSchema = typeof migrationLogRowSchema;
-export type TMigrationLogSave = TMigrationLogRowSchema["__infer"];
+export type TMigrationLogRow = {
+    id: number;
+    name: string;
+    branch: number;
+    action: string;
+    sql_source: string;
+    created_at: Date;
+};
+export type TMigrationLogInsert = Omit<TMigrationLogRow, "id">;
 export type TMigration = {
     up: () => string;
     down: () => string;
@@ -29,14 +26,14 @@ export declare enum TMigrationLogAction {
 }
 export type TMigrationsLogRepository = {
     getTable(): string;
-    createTableIfNotExists(): Promise<TQueryResult<never>>;
-    listRuned(): Promise<TQueryResult<TMigrationLogRowSchema>>;
-    listRunedByBranch(branch: number): Promise<TQueryResult<TMigrationLogRowSchema>>;
+    createTableIfNotExists(): Promise<TQueryResult>;
+    listRuned(): Promise<TQueryResult<TMigrationLogRow>>;
+    listRunedByBranch(branch: number): Promise<TQueryResult<TMigrationLogRow>>;
     getLastBranch(): Promise<Option<number>>;
-    create<const RC extends (keyof TMigrationLogSave)[]>(row: TInsertRow<TMigrationLogRowSchema>, returningColumns?: RC): Promise<TInsertRowResult<TMigrationLogRowSchema, RC>>;
+    create(row: TMigrationLogInsert, returningColumns?: readonly (keyof TMigrationLogRow)[]): Promise<TInsertRowResult<TMigrationLogRow>>;
     migrationLastAction(name: string): Promise<Option<string>>;
     migrationWillBeRuned(name: string): Promise<boolean>;
-    freshSchema(): Promise<TQueryResult<SchemaObject<any>>>;
+    freshSchema(): Promise<TQueryResult>;
 };
 export declare const Migrations: (groupName?: string) => TMigrations;
 export declare function Migration(migration: TMigration): TMigration;

package/build/migration.js

@@ -1,12 +1,4 @@
 import { panic } from "@smuzi/std";
-import { schema } from "@smuzi/schema";
-export const migrationLogRowSchema = schema.obj({
-    name: schema.string(),
-    branch: schema.number(),
-    action: schema.string(),
-    sql_source: schema.string(),
-    created_at: schema.datetime.native(),
-});
 export var TMigrationLogAction;
 (function (TMigrationLogAction) {
     TMigrationLogAction["up"] = "up";

package/build/types.d.ts

@@ -1,5 +1,4 @@
-import { Option, RecordFromKeys, Result, Simplify, StdError, StdRecord } from "@smuzi/std";
-import { SchemaObject, SchemaStorageAutoNumber } from "@smuzi/schema";
+import { Option, Result, StdError, StdRecord } from "@smuzi/std";
 import { TMigrations, TMigrationsLogRepository } from "./migration.js";
 export type TQueryParams = unknown[] | Record<string, unknown>;
 export declare class DBQueryError {
@@ -18,38 +17,31 @@ export declare class DBQueryError {
     });
     toError(): StdError;
 }
-export type TQueryRawResult<S extends SchemaObject> = {
-    rows: TableRows<S>;
+export type TQueryRawResult<Row extends Record<string, unknown> = Record<string, unknown>> = {
+    rows: TableRows<Row>;
     rowCount: Option<number>;
 };
-export type TQueryResult<S extends SchemaObject> = Result<TQueryRawResult<S>, DBQueryError>;
-export type TInsertRowResult<S extends SchemaObject, Columns extends readonly (keyof S["__infer"])[]> = Result<Option<Simplify<RecordFromKeys<S["__infer"], Columns>>>, DBQueryError>;
-export type TInsertManyRowResult<S extends SchemaObject, Columns extends readonly (keyof S["__infer"])[], Prepared extends SchemaObject = SchemaObject<RecordFromKeys<ReturnType<S["getConfig"]>, Columns>>> = Result<TableRows<Prepared>, DBQueryError>;
-export declare class TableRows<Schema extends SchemaObject, TableRow extends Option<Schema> extends Option<never> ? StdRecord<Record<string, unknown>> : StdRecord<Schema["__infer"]> = Option<Schema> extends Option<never> ? StdRecord<Record<string, unknown>> : StdRecord<Schema["__infer"]>, Rows extends Array<Record<string, unknown>> = Array<Record<string, unknown>>> {
+export type TQueryResult<Row extends Record<string, unknown> = Record<string, unknown>> = Result<TQueryRawResult<Row>, DBQueryError>;
+export type TInsertRowResult<Row extends Record<string, unknown>> = Result<Option<StdRecord<Row>>, DBQueryError>;
+export type TInsertManyRowResult<Row extends Record<string, unknown>> = Result<TableRows<Row>, DBQueryError>;
+export declare class TableRows<Row extends Record<string, unknown> = Record<string, unknown>> {
     #private;
-    constructor(schema: Option<Schema>, rows: Rows);
-    get(key: number): Option<TableRow>;
+    constructor(rows: Array<Record<string, unknown>>);
+    get(key: number): Option<StdRecord<Row>>;
     has(key: number): boolean;
-    entries(): IterableIterator<[number, TableRow]>;
-    [Symbol.iterator](): IterableIterator<[number, TableRow]>;
-    unsafeSource(): Rows;
+    entries(): IterableIterator<[number, StdRecord<Row>]>;
+    [Symbol.iterator](): IterableIterator<[number, StdRecord<Row>]>;
+    unsafeSource(): Record<string, unknown>[];
 }
 export interface TDatabaseClient {
-    query<S extends SchemaObject<any>>(sql: string, params?: TQueryParams, schema?: Option<S>): Promise<TQueryResult<S>>;
-    insertRow<S extends SchemaObject<any>, const RC extends string[]>(table: string, schema: S, row: TInsertRow<S>, returningColumns?: RC): Promise<TInsertRowResult<S, RC>>;
-    insertManyRows<S extends SchemaObject<any>, const RC extends string[]>(table: string, schema: S, rows: TInsertRow<S>[], returningColumns?: RC): Promise<TInsertManyRowResult<S, RC>>;
-    updateRowById<S extends SchemaObject<any>>(table: string, schema: S, id: number | string, row: Partial<TInsertRow<S>>, idColumn?: string): Promise<TQueryResult<S>>;
-    updateManyRows<S extends SchemaObject<any>>(table: string, values: Partial<TInsertRow<S>>, where: any): Promise<TQueryResult<S>>;
+    query<Row extends Record<string, unknown> = Record<string, unknown>>(sql: string, params?: TQueryParams): Promise<TQueryResult<Row>>;
+    insertRow<Insert extends Record<string, unknown>, Row extends Record<string, unknown> = Insert>(table: string, row: Insert, returningColumns?: readonly (keyof Row)[]): Promise<TInsertRowResult<Row>>;
+    insertManyRows<Insert extends Record<string, unknown>, Row extends Record<string, unknown> = Insert>(table: string, rows: Insert[], returningColumns?: readonly (keyof Row)[]): Promise<TInsertManyRowResult<Row>>;
+    updateRowById<Row extends Record<string, unknown>>(table: string, id: number | string, row: Partial<Row>, idColumn?: string): Promise<TQueryResult<Row>>;
+    updateManyRows<Row extends Record<string, unknown>>(table: string, values: Partial<Row>, where: string): Promise<TQueryResult<Row>>;
 }
 export type TDatabaseService = {
     client: TDatabaseClient;
     buildMigrations: () => TMigrations;
     buildMigrationLogRepository: (client: TDatabaseClient) => TMigrationsLogRepository;
 };
-export type IsExcludeSaving<T> = T extends SchemaStorageAutoNumber ? true : false;
-export type ExcludeExcludeSaveKeys<T> = {
-    [K in keyof T]: IsExcludeSaving<T[K]> extends true ? never : K;
-}[keyof T];
-export type TInsertRow<S extends SchemaObject> = S extends SchemaObject<infer U> ? {
-    [K in ExcludeExcludeSaveKeys<U>]: S["__infer"][K];
-} : {};

package/build/types.js

@@ -1,5 +1,4 @@
-import { None, OptionFromNullable, Some, StdError, StdRecord } from "@smuzi/std";
-import { SchemaOption, } from "@smuzi/schema";
+import { None, Some, StdError, StdRecord } from "@smuzi/std";
 export class DBQueryError {
     sql;
     message;
@@ -26,46 +25,12 @@ export class DBQueryError {
 }
 export class TableRows {
     #rows;
-    #schema;
-    constructor(schema, rows) {
+    constructor(rows) {
         this.#rows = rows;
-        this.#schema = schema;
-    }
-    #prepareRow(row) {
-        return this.#schema.match({
-            None: () => new StdRecord(row),
-            Some: (schema) => {
-                const config = schema.getConfig();
-                const prepare = {};
-                for (const field in config) {
-                    /**
-                     * TODO:
-                     * A database is a sufficiently reliable data source
-                     * to skip validating the retrieved data.
-                     * However, it is important to understand that type inference in this case
-                     * does not guarantee a 100% match with the actual database types.
-                     * This especially affects working with nullable fields.
-                     * For example, a field was required but later became nullable.
-                     * In this case, without changing the schema, `null` values will start flowing into your code.
-                     * This issue can be solved by `StdRecord`, but then all fields have to be handled as `Option`,
-                     * which is very inconvenient for developers.
-                    **/
-                    if (field in row) {
-                        if (config[field] instanceof SchemaOption) {
-                            prepare[field] = OptionFromNullable(row[field]);
-                        }
-                        else {
-                            prepare[field] = row[field];
-                        }
-                    }
-                }
-                return new StdRecord(prepare);
-            }
-        });
     }
     get(key) {
         if (this.has(key)) {
-            return Some(this.#prepareRow(this.#rows[key]));
+            return Some(new StdRecord(this.#rows[key]));
         }
         return None();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smuzi/database",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Database access layer and migrations toolkit for JavaScript and TypeScript",
   "type": "module",
   "types": "./build/index.d.ts",
@@ -33,9 +33,8 @@
     "#lib/*": "./src/*"
   },
   "peerDependencies": {
-    "@smuzi/std": "^0.2.13",
-    "@smuzi/schema": "^0.0.18",
-    "@smuzi/console": "^0.0.10"
+    "@smuzi/std": "^0.2.14",
+    "@smuzi/console": "^0.0.11"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",