ts-prorm-orm 1.1.0 → 1.2.0

package/dist/query-builders/update-builder.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Update query builder for the ORM
+ * Handles UPDATE queries with partial updates
+ */
+import { WhereOptions } from '../types';
+export interface UpdateQueryResult {
+    sql: string;
+    values: unknown[];
+}
+export interface UpdateBuilderOptions {
+    limit?: number;
+    returning?: boolean | string[];
+    dialect?: {
+        escape: (value: unknown) => string;
+        escapeId: (identifier: string) => string;
+    };
+}
+/**
+ * UpdateBuilder class for building UPDATE queries
+ */
+export declare class UpdateBuilder {
+    private options;
+    private whereBuilder;
+    constructor(options?: UpdateBuilderOptions);
+    /**
+     * Build an UPDATE query
+     */
+    build(tableName: string, values: Record<string, unknown>, where: WhereOptions): UpdateQueryResult;
+    /**
+     * Build a partial UPDATE query (only specified fields)
+     */
+    buildPartial(tableName: string, values: Record<string, unknown>, where: WhereOptions, fields?: string[]): UpdateQueryResult;
+    /**
+     * Build an UPDATE query with increment/decrement operations
+     */
+    buildWithOperations(tableName: string, operations: Record<string, {
+        op: '+' | '-' | '*' | '/' | 'SET';
+        value: number;
+    }>, where: WhereOptions): UpdateQueryResult;
+    /**
+     * Build a batch UPDATE query (for bulk updates)
+     */
+    buildBatch(tableName: string, records: Array<{
+        values: Record<string, unknown>;
+        where: WhereOptions;
+    }>): UpdateQueryResult[];
+    /**
+     * Build the RETURNING clause
+     */
+    private buildReturningClause;
+    /**
+     * Escape an identifier
+     */
+    private escapeId;
+}
+/**
+ * Create an UpdateBuilder instance
+ */
+export declare function createUpdateBuilder(options?: UpdateBuilderOptions): UpdateBuilder;
+/**
+ * Quick helper to build an UPDATE query
+ */
+export declare function buildUpdateQuery(tableName: string, values: Record<string, unknown>, where: WhereOptions, options?: UpdateBuilderOptions): UpdateQueryResult;
+/**
+ * Quick helper to build an UPDATE query with increment/decrement
+ */
+export declare function buildUpdateWithOperations(tableName: string, operations: Record<string, {
+    op: '+' | '-' | '*' | '/' | 'SET';
+    value: number;
+}>, where: WhereOptions, options?: UpdateBuilderOptions): UpdateQueryResult;
+export default UpdateBuilder;

package/dist/query-builders/view-builder.d.ts

@@ -0,0 +1,189 @@
+/**
+ * View Builder
+ * Provides an ORM-like way to create database views
+ */
+import { WhereOptions, AttributesOptions, Order } from '../types';
+export interface ViewColumn {
+    /** Column name in the view */
+    name: string;
+    /** Expression or column reference */
+    expression: string | {
+        model: string;
+        column: string;
+    };
+    /** Alias for the column */
+    alias?: string;
+}
+export interface ViewJoin {
+    /** Model or table name to join */
+    model: string | {
+        tableName?: string;
+        name?: string;
+    };
+    /** Join type */
+    type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+    /** Join condition */
+    on: Record<string, any>;
+    /** Alias for the joined model */
+    as?: string;
+}
+export interface ViewSelectOptions {
+    /** Model name or table to select from */
+    model: string | {
+        tableName?: string;
+        name?: string;
+    };
+    /** Columns to include */
+    columns?: AttributesOptions;
+    /** Join specifications */
+    joins?: ViewJoin[];
+    /** Where conditions */
+    where?: WhereOptions;
+    /** Group by */
+    group?: string | string[];
+    /** Having conditions */
+    having?: WhereOptions;
+    /** Order by */
+    order?: Order;
+    /** Limit */
+    limit?: number;
+    /** Offset */
+    offset?: number;
+    /** Distinct */
+    distinct?: boolean;
+}
+export interface ViewOptions {
+    /** View name */
+    name: string;
+    /** Schema for the view */
+    schema?: string;
+    /** Comment for the view */
+    comment?: string;
+    /** Replace if exists */
+    replace?: boolean;
+}
+export interface MaterializedViewOptions extends ViewOptions {
+    /** Columns to cluster on */
+    clusterOn?: string[];
+    /** Storage parameters */
+    storageParams?: Record<string, string>;
+}
+/**
+ * Builder for creating database views
+ */
+export declare class ViewBuilder {
+    private columns;
+    private fromModel?;
+    private joins;
+    private whereConditions?;
+    private groupByClause?;
+    private havingConditions?;
+    private orderByClause?;
+    private limitVal?;
+    private offsetVal?;
+    private distinctVal?;
+    private viewOptions?;
+    /**
+     * Set the primary model to select from
+     * Accepts model class or table name string
+     * @example
+     * .from(User)
+     * .from('users')
+     */
+    from(model: string | {
+        tableName?: string;
+        name?: string;
+    }): ViewBuilder;
+    /**
+     * Add a column to select
+     */
+    selectColumn(column: string, opts?: {
+        alias?: string;
+        expression?: string;
+    }): ViewBuilder;
+    /**
+     * Add multiple columns at once
+     */
+    selectColumns(columns: string[]): ViewBuilder;
+    /**
+     * Add all columns from a model
+     */
+    selectAll(model: string | {
+        tableName?: string;
+        name?: string;
+    }, opts?: {
+        prefix?: string;
+    }): ViewBuilder;
+    /**
+     * Add a join to the view
+     * @example
+     * .join({ model: Post, type: 'LEFT', on: { userId: 'users.id' } })
+     * .join({ model: 'posts', type: 'LEFT', on: { userId: 'users.id' } })
+     */
+    join(opts: {
+        model: string | {
+            tableName?: string;
+            name?: string;
+        };
+        type?: ViewJoin['type'];
+        on: Record<string, any>;
+        as?: string;
+    }): ViewBuilder;
+    /**
+     * Add WHERE conditions
+     */
+    where(conditions: WhereOptions): ViewBuilder;
+    /**
+     * Add GROUP BY
+     */
+    groupBy(columns: string | string[]): ViewBuilder;
+    /**
+     * Add HAVING conditions
+     */
+    having(conditions: WhereOptions): ViewBuilder;
+    /**
+     * Add ORDER BY
+     */
+    orderBy(order: Order): ViewBuilder;
+    /**
+     * Add LIMIT
+     */
+    limit(limit: number): ViewBuilder;
+    /**
+     * Add OFFSET
+     */
+    offset(offset: number): ViewBuilder;
+    /**
+     * Add DISTINCT
+     */
+    distinct(): ViewBuilder;
+    /**
+     * Set view options
+     */
+    options(opts: Partial<ViewOptions>): ViewBuilder;
+    /**
+     * Get the view options
+     */
+    getOptions(): Partial<ViewOptions>;
+    /**
+     * Build the SELECT query for the view
+     */
+    toSelectQuery(): ViewSelectOptions;
+    /**
+     * Build and return the SQL string
+     */
+    toSQL(dialect: any): string;
+    /**
+     * Reset the builder
+     */
+    reset(): void;
+}
+/**
+ * Create a new view builder
+ */
+export declare function createViewBuilder(): ViewBuilder;
+declare const _default: {
+    ViewBuilder: typeof ViewBuilder;
+    createViewBuilder: typeof createViewBuilder;
+};
+export default _default;

package/dist/query-builders/where-builder.d.ts

@@ -0,0 +1,124 @@
+/**
+ * WHERE clause builder for the ORM
+ * Handles complex WHERE conditions with all supported operators
+ */
+import { WhereOptions } from '../types';
+/**
+ * Result of building a WHERE clause: the SQL fragment (with `?` placeholders) and its bound values
+ */
+export interface WhereClauseResult {
+    sql: string;
+    values: unknown[];
+}
+/**
+ * Options controlling how a WhereBuilder generates SQL
+ */
+export interface WhereBuilderOptions {
+    replacements?: Record<string, unknown>;
+    model?: unknown;
+    dialect?: {
+        escape: (value: unknown) => string;
+        escapeId: (identifier: string) => string;
+    };
+    /** Dialect name for dialect-specific SQL generation (e.g., 'sqlite', 'mysql', 'postgres') */
+    dialectName?: string;
+}
+/**
+ * WhereBuilder class for building WHERE clauses
+ */
+export declare class WhereBuilder {
+    private options;
+    constructor(options?: WhereBuilderOptions);
+    /**
+     * Build a WHERE clause from WhereOptions
+     */
+    build(where: WhereOptions): WhereClauseResult;
+    /**
+     * Build a condition (can be nested)
+     */
+    private buildCondition;
+    /**
+     * Check if the object has Op.not as a key (can be string or Symbol)
+     */
+    private hasOpNotKey;
+    /**
+     * Build a condition with Op.not - { [Op.not]: { ... } } or { not: { ... } }
+     */
+    private buildOpNotCondition;
+    /**
+     * Build a $where condition with column reference
+     * { $col: 'user.id', $eq: 1 } => "user"."id" = ?
+     */
+    private buildWhereCondition;
+    /**
+     * Build a single where operator condition
+     * Handles special value types like $col (column references) and $literal (raw SQL)
+     */
+    private buildSingleWhereOperator;
+    /**
+     * Check if the object has Op.and, Op.or, or Op.not as keys (Symbol-based logical operators)
+     */
+    private hasLogicalOperatorSymbols;
+    /**
+     * Check if the object is a logical operator container
+     */
+    private isLogicalOperator;
+    /**
+     * Build logical conditions ($and, $or, $not) or Symbol-based (Op.and, Op.or, Op.not)
+     */
+    private buildLogicalCondition;
+    /**
+     * Check if a key is a JSON path Symbol created by Op.json
+     * JSON path symbols have descriptions like "json:$.path" or "json:path"
+     */
+    private isJsonPathSymbol;
+    /**
+     * Extract the JSON path from a Symbol created by Op.json
+     * The path is stored in the Symbol's description after "json:"
+     */
+    private extractJsonPath;
+    /**
+     * Build field-level conditions
+     */
+    private buildFieldConditions;
+    /**
+     * Build condition for a specific operator
+     */
+    private buildOperatorCondition;
+    /**
+     * Escape an identifier (column/table name)
+     */
+    private escapeId;
+    /**
+     * Escape a value for use in a query
+     */
+    private escapeValue;
+    /**
+     * Build a PostgreSQL array literal from an array value
+     * e.g., ['a', 'b'] => ARRAY['a', 'b']
+     */
+    private buildArrayLiteral;
+    /**
+     * Build a JSON extraction expression based on the dialect
+     * SQLite/MySQL: json_extract(column, '$.path')
+     * PostgreSQL: column->>'path' or #>>'{path}'
+     *
+     * @param field - The JSON/JSONB column name
+     * @param path - The JSON path to extract (e.g., 'settings.theme' or '$.settings.theme')
+     * @returns SQL fragment for JSON extraction
+     */
+    private buildJsonExtract;
+    /**
+     * Build a JSON path query - alias for buildJsonExtract for compatibility
+     */
+    private jsonExtract;
+}
+/**
+ * Create a WhereBuilder instance with default options
+ */
+export declare function createWhereBuilder(options?: WhereBuilderOptions): WhereBuilder;
+/**
+ * Quick helper to build a WHERE clause
+ */
+export declare function buildWhereClause(where: WhereOptions, options?: WhereBuilderOptions): WhereClauseResult;
+export default WhereBuilder;