@veap/database 0.0.0-stage → 0.1.0

package/dist/provider.d.ts

@@ -0,0 +1,12 @@
+import { ServiceProvider } from "@veap/kernel";
+import type { DatabaseConfig } from "./types";
+export interface DatabaseProviderConfig {
+    databaseUrl?: string;
+    config?: DatabaseConfig;
+}
+export declare class DatabaseServiceProvider extends ServiceProvider {
+    private config?;
+    constructor(container: any, config?: DatabaseProviderConfig);
+    register(): void;
+    boot(): Promise<void>;
+}

package/dist/provider.js

@@ -0,0 +1,58 @@
+import { ConfigService, DATABASE, ServiceProvider } from "@veap/kernel";
+import knex from "knex";
+import { initDatabase, isSqliteDatabase, resolvePostgresSslConfig, resolveSqliteFilename, setKnex, } from "./connection";
+import { debug } from "./logger";
+export class DatabaseServiceProvider extends ServiceProvider {
+    config;
+    constructor(container, config) {
+        super(container);
+        this.config = config;
+    }
+    register() {
+        // Port token registration
+    }
+    async boot() {
+        const configService = await this.container.resolve(ConfigService);
+        const databaseUrl = this.config?.databaseUrl ||
+            configService.get("DATABASE_URL") ||
+            process.env.DATABASE_URL ||
+            process.env.DATABASE_FILE;
+        const isProd = configService.get("NODE_ENV") === "production" ||
+            process.env.NODE_ENV === "production";
+        if (this.config?.config) {
+            const instance = initDatabase(this.config.config);
+            this.container.register({ token: DATABASE, useValue: instance });
+            this.container.register({ token: "Knex", useValue: instance });
+            return;
+        }
+        const resolvedUrl = databaseUrl || "dev.sqlite";
+        const isSqlite = isSqliteDatabase(resolvedUrl);
+        const client = isSqlite ? "better-sqlite3" : "pg";
+        debug("veap:database", `Auto-initializing Knex from DATABASE_URL with client: ${client}`);
+        const ssl = resolvePostgresSslConfig({
+            databaseUrl: resolvedUrl,
+            isProd,
+            rejectUnauthorizedEnv: configService.get("DATABASE_SSL_REJECT_UNAUTHORIZED"),
+            caCert: configService.get("DATABASE_SSL_CA"),
+        });
+        const instance = knex({
+            client,
+            connection: isSqlite
+                ? { filename: resolveSqliteFilename(resolvedUrl) }
+                : {
+                    connectionString: resolvedUrl,
+                    ssl,
+                },
+            useNullAsDefault: true,
+        });
+        setKnex(instance);
+        this.container.register({
+            token: DATABASE,
+            useValue: instance,
+        });
+        this.container.register({
+            token: "Knex",
+            useValue: instance,
+        });
+    }
+}

package/dist/query-builder.d.ts

@@ -0,0 +1,197 @@
+import type { Knex } from "knex";
+import type { Model } from "./model";
+export declare class ModelQueryBuilder<M extends Model = any> {
+    modelClass: any;
+    [key: string]: any;
+    protected knexBuilder: Knex.QueryBuilder;
+    protected eagerRelations: string[];
+    protected _withTrashed: boolean;
+    protected _onlyTrashed: boolean;
+    protected _softDeleteScopeApplied: boolean;
+    protected _scopesApplied: boolean;
+    protected _ignoredGlobalScopes: Set<string>;
+    protected _ignoreAllGlobalScopes: boolean;
+    constructor(modelClass: any, // typeof Model
+    customKnexBuilder?: Knex.QueryBuilder);
+    /**
+     * Explicitly applies a local scope method by name.
+     */
+    scope(name: string, ...args: any[]): this;
+    /**
+     * Excludes a specific global scope from this query.
+     */
+    withoutGlobalScope(scope: string): this;
+    /**
+     * Excludes multiple or all global scopes from this query.
+     */
+    withoutGlobalScopes(scopes?: string[]): this;
+    /**
+     * Includes soft-deleted models in query results.
+     */
+    withTrashed(): this;
+    /**
+     * Restricts query to only soft-deleted models.
+     */
+    onlyTrashed(): this;
+    /**
+     * Applies both user-defined global scopes and soft-delete scope.
+     */
+    protected applyGlobalScopes(): void;
+    /**
+     * Applies the soft delete filter to the underlying query if enabled.
+     */
+    protected applySoftDeleteScope(): void;
+    /**
+     * Returns the underlying Knex query builder.
+     */
+    toKnex(): Knex.QueryBuilder;
+    /**
+     * Basic WHERE clause. Automatically maps camelCase to snake_case columns.
+     */
+    where(column: any, operator?: any, value?: any): this;
+    orWhere(column: any, operator?: any, value?: any): this;
+    whereIn(column: string, values: any[]): this;
+    whereNotIn(column: string, values: any[]): this;
+    whereNull(column: string): this;
+    whereNotNull(column: string): this;
+    whereBetween(column: string, range: [any, any]): this;
+    whereLike(column: string, pattern: string): this;
+    whereILike(column: string, pattern: string): this;
+    select(...columns: any[]): this;
+    orderBy(column: string, direction?: "asc" | "desc"): this;
+    latest(column?: string): this;
+    oldest(column?: string): this;
+    limit(count: number): this;
+    take(count: number): this;
+    offset(count: number): this;
+    skip(count: number): this;
+    join(table: string, first: string, operatorOrSecond: string, second?: string): this;
+    leftJoin(table: string, first: string, operatorOrSecond: string, second?: string): this;
+    /**
+     * Eager load relations (e.g. .with('author', 'posts.comments'))
+     */
+    with(...relations: (string | string[])[]): this;
+    /**
+     * Helper to retrieve a relation instance from a temporary model instance.
+     */
+    protected getRelationInstance(relationName: string): any;
+    /**
+     * Builds an EXISTS or COUNT subquery for a relation.
+     */
+    protected buildRelationSubquery(sub: Knex.QueryBuilder, relationName: string, callback?: (builder: ModelQueryBuilder) => void, isCount?: boolean): void;
+    /**
+     * Adds a relationship count condition to the query with where clause.
+     */
+    has(relation: string, operator?: string, count?: number, boolean?: "and" | "or", callback?: (query: ModelQueryBuilder) => void): this;
+    /**
+     * Adds an OR relationship count condition to the query.
+     */
+    orHas(relation: string, operator?: string, count?: number, callback?: (query: ModelQueryBuilder) => void): this;
+    /**
+     * Adds a relationship existence condition with an optional callback constraint.
+     */
+    whereHas(relation: string, callback?: (query: ModelQueryBuilder) => void): this;
+    /**
+     * Adds an OR relationship existence condition with an optional callback constraint.
+     */
+    orWhereHas(relation: string, callback?: (query: ModelQueryBuilder) => void): this;
+    /**
+     * Adds a relationship absence condition with an optional callback constraint.
+     */
+    whereDoesntHave(relation: string, callback?: (query: ModelQueryBuilder) => void): this;
+    /**
+     * Adds an OR relationship absence condition with an optional callback constraint.
+     */
+    orWhereDoesntHave(relation: string, callback?: (query: ModelQueryBuilder) => void): this;
+    /**
+     * Alias for whereDoesntHave.
+     */
+    doesntHave(relation: string): this;
+    /**
+     * Alias for orWhereDoesntHave.
+     */
+    orDoesntHave(relation: string): this;
+    /**
+     * Adds subquery counts for related models as `{relation}_count`.
+     */
+    withCount(...relations: (string | string[] | Record<string, ((q: ModelQueryBuilder) => void) | undefined>)[]): this;
+    /**
+     * Executes query and returns hydrated Model instances.
+     */
+    get(): Promise<M[]>;
+    /**
+     * Returns the first matched Model instance or null.
+     */
+    first(): Promise<M | null>;
+    /**
+     * Returns the first matched Model or throws an error.
+     */
+    firstOrFail(): Promise<M>;
+    /**
+     * Get the first record matching the attributes or instantiate it.
+     */
+    firstOrNew(attributes: Record<string, any>, values?: Record<string, any>): Promise<M>;
+    /**
+     * Get the first record matching the attributes or create it.
+     */
+    firstOrCreate(attributes: Record<string, any>, values?: Record<string, any>): Promise<M>;
+    /**
+     * Create or update a record matching the attributes, and fill it with values.
+     */
+    updateOrCreate(attributes: Record<string, any>, values?: Record<string, any>): Promise<M>;
+    /**
+     * Finds a record by its primary key.
+     */
+    find(id: any): Promise<M | null>;
+    /**
+     * Finds a record by primary key or throws an error.
+     */
+    findOrFail(id: any): Promise<M>;
+    /**
+     * Counts rows matching criteria.
+     */
+    count(column?: string): Promise<number>;
+    /**
+     * Checks if any records exist matching criteria.
+     */
+    exists(): Promise<boolean>;
+    /**
+     * Plucks a single column's values into an array.
+     */
+    pluck<K extends string>(column: K): Promise<any[]>;
+    /**
+     * Paginates results.
+     */
+    paginate(page?: number, perPage?: number): Promise<{
+        data: M[];
+        total: number;
+        page: number;
+        perPage: number;
+        lastPage: number;
+    }>;
+    /**
+     * Bulk updates matching records.
+     */
+    update(attributes: Record<string, any>): Promise<number>;
+    /**
+     * Bulk deletes matching records (soft-deletes if softDeletes is enabled).
+     */
+    delete(): Promise<number>;
+    /**
+     * Bulk force-deletes matching records (hard delete regardless of softDeletes setting).
+     */
+    forceDelete(): Promise<number>;
+    /**
+     * Bulk restores soft-deleted matching records.
+     */
+    restore(): Promise<number>;
+    /**
+     * Increments column value.
+     */
+    increment(column: string, amount?: number): Promise<number>;
+    /**
+     * Decrements column value.
+     */
+    decrement(column: string, amount?: number): Promise<number>;
+    toSQL(): Knex.Sql;
+}