@danceroutine/tango-orm 0.1.0

package/dist/query/compiler/QueryCompiler.js

@@ -0,0 +1,183 @@
+import { InternalDialect } from '../domain/internal/InternalDialect';
+import { InternalQNodeType } from '../domain/internal/InternalQNodeType';
+import { InternalLookupType } from '../domain/internal/InternalLookupType';
+export class QueryCompiler {
+    meta;
+    dialect;
+    static BRAND = 'tango.orm.query_compiler';
+    __tangoBrand = QueryCompiler.BRAND;
+    static isQueryCompiler(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value.__tangoBrand === QueryCompiler.BRAND);
+    }
+    constructor(meta, dialect = InternalDialect.POSTGRES) {
+        this.meta = meta;
+        this.dialect = dialect;
+    }
+    compile(state) {
+        const whereParts = [];
+        const params = [];
+        if (state.q) {
+            const result = this.compileQNode(state.q, params.length + 1);
+            if (result.sql) {
+                whereParts.push(result.sql);
+                params.push(...result.params);
+            }
+        }
+        state.excludes?.forEach((exclude) => {
+            const result = this.compileQNode({ kind: InternalQNodeType.NOT, node: exclude }, params.length + 1);
+            if (result.sql) {
+                whereParts.push(result.sql);
+                params.push(...result.params);
+            }
+        });
+        const select = state.select?.map(String).join(', ') || `${this.meta.table}.*`;
+        const joins = (state.selectRelated ?? [])
+            .map((rel) => {
+            const r = this.meta.relations?.[rel];
+            if (!r || r.kind !== 'belongsTo') {
+                return '';
+            }
+            return `LEFT JOIN ${r.table} ${r.alias} ON ${r.alias}.${r.targetPk} = ${this.meta.table}.${r.localKey}`;
+        })
+            .filter(Boolean)
+            .join(' ');
+        const whereSQL = whereParts.length ? ` WHERE ${whereParts.join(' AND ')}` : '';
+        const orderSQL = ` ORDER BY ${state.order?.length
+            ? state.order.map((o) => `${this.meta.table}.${String(o.by)} ${o.dir.toUpperCase()}`).join(', ')
+            : `${this.meta.table}.${this.meta.pk} ASC`}`;
+        const limitSQL = state.limit ? ` LIMIT ${state.limit}` : '';
+        const offsetSQL = state.offset ? ` OFFSET ${state.offset}` : '';
+        const sql = `SELECT ${select} FROM ${this.meta.table}${joins ? ' ' + joins : ''}${whereSQL}${orderSQL}${limitSQL}${offsetSQL}`;
+        return { sql, params };
+    }
+    compileQNode(node, paramIndex) {
+        switch (node.kind) {
+            case InternalQNodeType.ATOM:
+                return this.compileAtom(node.where || {}, paramIndex);
+            case InternalQNodeType.AND:
+                return this.compileAnd(node.nodes || [], paramIndex);
+            case InternalQNodeType.OR:
+                return this.compileOr(node.nodes || [], paramIndex);
+            case InternalQNodeType.NOT:
+                return this.compileNot(node.node, paramIndex);
+            default:
+                return { sql: '', params: [] };
+        }
+    }
+    compileAtom(where, paramIndex) {
+        const entries = Object.entries(where).filter(([, value]) => value !== undefined);
+        const { parts, params } = entries.reduce((accumulator, [key, value]) => {
+            const [field, lookup = InternalLookupType.EXACT] = String(key).split('__');
+            const col = `${this.meta.table}.${field}`;
+            const idx = paramIndex + accumulator.params.length;
+            const clause = this.lookupToSQL(col, lookup, value, idx);
+            accumulator.parts.push(clause.sql);
+            accumulator.params.push(...clause.params);
+            return accumulator;
+        }, { parts: [], params: [] });
+        return {
+            sql: parts.length ? `(${parts.join(' AND ')})` : '',
+            params,
+        };
+    }
+    compileAnd(nodes, paramIndex) {
+        const { parts, params } = nodes.reduce((accumulator, node) => {
+            const result = this.compileQNode(node, paramIndex + accumulator.params.length);
+            if (result.sql) {
+                accumulator.parts.push(result.sql);
+                accumulator.params.push(...result.params);
+            }
+            return accumulator;
+        }, { parts: [], params: [] });
+        return {
+            sql: parts.length ? `(${parts.join(' AND ')})` : '',
+            params,
+        };
+    }
+    compileOr(nodes, paramIndex) {
+        const { parts, params } = nodes.reduce((accumulator, node) => {
+            const result = this.compileQNode(node, paramIndex + accumulator.params.length);
+            if (result.sql) {
+                accumulator.parts.push(result.sql);
+                accumulator.params.push(...result.params);
+            }
+            return accumulator;
+        }, { parts: [], params: [] });
+        return {
+            sql: parts.length ? `(${parts.join(' OR ')})` : '',
+            params,
+        };
+    }
+    compileNot(node, paramIndex) {
+        const result = this.compileQNode(node, paramIndex);
+        if (!result.sql) {
+            return { sql: '', params: [] };
+        }
+        return {
+            sql: `(NOT ${result.sql})`,
+            params: result.params,
+        };
+    }
+    lookupToSQL(col, lookup, value, paramIndex) {
+        const placeholder = this.dialect === InternalDialect.POSTGRES ? `$${paramIndex}` : '?';
+        const normalized = this.normalizeParam(value);
+        switch (lookup) {
+            case InternalLookupType.EXACT:
+                if (value === null) {
+                    return { sql: `${col} IS NULL`, params: [] };
+                }
+                return { sql: `${col} = ${placeholder}`, params: [normalized] };
+            case InternalLookupType.LT:
+                return { sql: `${col} < ${placeholder}`, params: [normalized] };
+            case InternalLookupType.LTE:
+                return { sql: `${col} <= ${placeholder}`, params: [normalized] };
+            case InternalLookupType.GT:
+                return { sql: `${col} > ${placeholder}`, params: [normalized] };
+            case InternalLookupType.GTE:
+                return { sql: `${col} >= ${placeholder}`, params: [normalized] };
+            case InternalLookupType.IN: {
+                const arr = (Array.isArray(value) ? value : [value]).map((entry) => this.normalizeParam(entry));
+                if (arr.length === 0) {
+                    return { sql: '1=0', params: [] };
+                }
+                const placeholders = this.dialect === InternalDialect.POSTGRES
+                    ? arr.map((_, i) => `$${paramIndex + i}`).join(', ')
+                    : arr.map(() => '?').join(', ');
+                return { sql: `${col} IN (${placeholders})`, params: arr };
+            }
+            case InternalLookupType.ISNULL:
+                return { sql: value ? `${col} IS NULL` : `${col} IS NOT NULL`, params: [] };
+            case InternalLookupType.CONTAINS:
+                return { sql: `${col} LIKE ${placeholder}`, params: [`%${value}%`] };
+            case InternalLookupType.ICONTAINS: {
+                const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
+                const lowerValue = String(value).toLowerCase();
+                return { sql: `${lowerCol} LIKE ${placeholder}`, params: [`%${lowerValue}%`] };
+            }
+            case InternalLookupType.STARTSWITH:
+                return { sql: `${col} LIKE ${placeholder}`, params: [`${value}%`] };
+            case InternalLookupType.ISTARTSWITH: {
+                const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
+                const lowerValue = String(value).toLowerCase();
+                return { sql: `${lowerCol} LIKE ${placeholder}`, params: [`${lowerValue}%`] };
+            }
+            case InternalLookupType.ENDSWITH:
+                return { sql: `${col} LIKE ${placeholder}`, params: [`%${value}`] };
+            case InternalLookupType.IENDSWITH: {
+                const lowerCol = this.dialect === InternalDialect.POSTGRES ? `LOWER(${col})` : `${col}`;
+                const lowerValue = String(value).toLowerCase();
+                return { sql: `${lowerCol} LIKE ${placeholder}`, params: [`%${lowerValue}`] };
+            }
+            default:
+                throw new Error(`Unknown lookup: ${lookup}`);
+        }
+    }
+    normalizeParam(value) {
+        if (this.dialect === InternalDialect.SQLITE && typeof value === 'boolean') {
+            return value ? 1 : 0;
+        }
+        return value;
+    }
+}

package/dist/query/compiler/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { QueryCompiler } from './QueryCompiler';

package/dist/query/domain/CompiledQuery.d.ts

@@ -0,0 +1,4 @@
+export interface CompiledQuery {
+    sql: string;
+    params: readonly unknown[];
+}

package/dist/query/domain/CompiledQuery.js

@@ -0,0 +1 @@
+export {};

package/dist/query/domain/Dialect.d.ts

@@ -0,0 +1,2 @@
+import type { InternalDialect } from './internal/InternalDialect';
+export type Dialect = (typeof InternalDialect)[keyof typeof InternalDialect];

package/dist/query/domain/Direction.d.ts

@@ -0,0 +1,2 @@
+import type { InternalDirection } from './internal/InternalDirection';
+export type Direction = (typeof InternalDirection)[keyof typeof InternalDirection];

package/dist/query/domain/FilterInput.d.ts

@@ -0,0 +1,3 @@
+import type { FilterKey } from './FilterKey';
+import type { FilterValue } from './FilterValue';
+export type FilterInput<T> = Partial<Record<FilterKey<T>, FilterValue>>;

package/dist/query/domain/FilterKey.d.ts

@@ -0,0 +1,2 @@
+import type { LookupType } from '.';
+export type FilterKey<T> = keyof T | `${string & keyof T}__${LookupType}`;

package/dist/query/domain/FilterValue.d.ts

@@ -0,0 +1 @@
+export type FilterValue = string | number | boolean | Date | null | undefined | Array<string | number>;

package/dist/query/domain/LookupType.d.ts

@@ -0,0 +1,2 @@
+import type { InternalLookupType } from './internal/InternalLookupType';
+export type LookupType = (typeof InternalLookupType)[keyof typeof InternalLookupType];

package/dist/query/domain/OrderSpec.d.ts

@@ -0,0 +1,5 @@
+import type { Direction } from '.';
+export interface OrderSpec<T> {
+    by: keyof T;
+    dir: Direction;
+}

package/dist/query/domain/OrderToken.d.ts

@@ -0,0 +1 @@
+export type OrderToken<T> = keyof T | `-${string & keyof T}`;

package/dist/query/domain/QNode.d.ts

@@ -0,0 +1,9 @@
+import type { FilterInput } from './FilterInput';
+import type { InternalQNodeType } from './internal/InternalQNodeType';
+export type QNodeType = (typeof InternalQNodeType)[keyof typeof InternalQNodeType];
+export interface QNode<T> {
+    kind: QNodeType;
+    where?: FilterInput<T>;
+    nodes?: QNode<T>[];
+    node?: QNode<T>;
+}

package/dist/query/domain/QueryResult.d.ts

@@ -0,0 +1,4 @@
+export interface QueryResult<T> {
+    results: T[];
+    nextCursor?: string | null;
+}

package/dist/query/domain/QuerySetState.d.ts

@@ -0,0 +1,13 @@
+import type { OrderSpec } from './OrderSpec';
+import type { QNode } from './QNode';
+export interface QuerySetState<T> {
+    q?: QNode<T>;
+    excludes?: QNode<T>[];
+    order?: OrderSpec<T>[];
+    limit?: number;
+    offset?: number;
+    cursor?: string | null;
+    selectRelated?: string[];
+    prefetchRelated?: string[];
+    select?: (keyof T)[];
+}

package/dist/query/domain/RelationMeta.d.ts

@@ -0,0 +1,10 @@
+import type { InternalRelationKind } from './internal/InternalRelationKind';
+export type RelationKind = (typeof InternalRelationKind)[keyof typeof InternalRelationKind];
+export interface RelationMeta {
+    kind: RelationKind;
+    table: string;
+    targetPk: string;
+    localKey?: string;
+    foreignKey?: string;
+    alias: string;
+}

package/dist/query/domain/RepositoryMeta.d.ts

@@ -0,0 +1,7 @@
+import type { RelationMeta } from './RelationMeta';
+export interface RepositoryMeta {
+    table: string;
+    pk: string;
+    columns: Record<string, string>;
+    relations?: Record<string, RelationMeta>;
+}

package/dist/query/domain/WhereClause.d.ts

@@ -0,0 +1,4 @@
+export interface WhereClause {
+    sql: string;
+    params: readonly unknown[];
+}

package/dist/query/domain/WhereClause.js

@@ -0,0 +1 @@
+export {};

package/dist/query/domain/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export type { CompiledQuery } from './CompiledQuery';
+export type { Dialect } from './Dialect';
+export type { Direction } from './Direction';
+export type { FilterInput } from './FilterInput';
+export type { FilterKey } from './FilterKey';
+export type { FilterValue } from './FilterValue';
+export type { LookupType } from './LookupType';
+export type { OrderSpec } from './OrderSpec';
+export type { OrderToken } from './OrderToken';
+export type { QNode } from './QNode';
+export type { QueryResult } from './QueryResult';
+export type { QuerySetState } from './QuerySetState';
+export type { RelationMeta } from './RelationMeta';
+export type { RepositoryMeta as RepoMeta } from './RepositoryMeta';
+export type { WhereClause } from './WhereClause';

package/dist/query/domain/internal/InternalDialect.d.ts

@@ -0,0 +1,4 @@
+export declare const InternalDialect: {
+    readonly POSTGRES: "postgres";
+    readonly SQLITE: "sqlite";
+};

package/dist/query/domain/internal/InternalDirection.d.ts

@@ -0,0 +1,4 @@
+export declare const InternalDirection: {
+    readonly ASC: "asc";
+    readonly DESC: "desc";
+};

package/dist/query/domain/internal/InternalLookupType.d.ts

@@ -0,0 +1,15 @@
+export declare const InternalLookupType: {
+    readonly EXACT: "exact";
+    readonly LT: "lt";
+    readonly LTE: "lte";
+    readonly GT: "gt";
+    readonly GTE: "gte";
+    readonly IN: "in";
+    readonly ISNULL: "isnull";
+    readonly CONTAINS: "contains";
+    readonly ICONTAINS: "icontains";
+    readonly STARTSWITH: "startswith";
+    readonly ISTARTSWITH: "istartswith";
+    readonly ENDSWITH: "endswith";
+    readonly IENDSWITH: "iendswith";
+};

package/dist/query/domain/internal/InternalQNodeType.d.ts

@@ -0,0 +1,6 @@
+export declare const InternalQNodeType: {
+    readonly ATOM: "atom";
+    readonly AND: "and";
+    readonly OR: "or";
+    readonly NOT: "not";
+};

package/dist/query/domain/internal/InternalRelationKind.d.ts

@@ -0,0 +1,5 @@
+export declare const InternalRelationKind: {
+    readonly HAS_MANY: "hasMany";
+    readonly BELONGS_TO: "belongsTo";
+    readonly HAS_ONE: "hasOne";
+};

package/dist/query/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Domain boundary barrel: exposes namespaced exports for Django-style drill-down
+ * imports and curated flat exports for TS-native ergonomics.
+ */
+export * as compiler from './compiler/index';
+export * as domain from './domain/index';
+export type * from './domain/index';
+export type { RepoMeta } from './domain/index';
+export { QuerySet } from './QuerySet';
+export type { RepositoryLike } from './QuerySet';
+export { QBuilder, QBuilder as Q } from './QBuilder';
+export { QueryCompiler } from './compiler/index';

package/dist/query/index.js

@@ -0,0 +1,4 @@
+import { QBuilder, QueryCompiler, QuerySet, compiler_exports } from "../QuerySet-BzR5QzGi.js";
+import { domain_exports } from "../query-CQbvLeuh.js";
+
+export { QBuilder as Q, QBuilder, QueryCompiler, QuerySet, compiler_exports as compiler, domain_exports as domain };

package/dist/query-CQbvLeuh.js

@@ -0,0 +1,21 @@
+import { __export } from "./chunk-DLY2FNSh.js";
+import { QBuilder, QueryCompiler, QuerySet, compiler_exports } from "./QuerySet-BzR5QzGi.js";
+
+//#region src/query/domain/index.ts
+var domain_exports = {};
+
+//#endregion
+//#region src/query/index.ts
+var query_exports = {};
+__export(query_exports, {
+	Q: () => QBuilder,
+	QBuilder: () => QBuilder,
+	QueryCompiler: () => QueryCompiler,
+	QuerySet: () => QuerySet,
+	compiler: () => compiler_exports,
+	domain: () => domain_exports
+});
+
+//#endregion
+export { domain_exports, query_exports };
+//# sourceMappingURL=query-CQbvLeuh.js.map

package/dist/query-CQbvLeuh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-CQbvLeuh.js","names":[],"sources":["../src/query/domain/index.ts","../src/query/index.ts"],"sourcesContent":["/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport type { CompiledQuery } from './CompiledQuery';\nexport type { Dialect } from './Dialect';\nexport type { Direction } from './Direction';\nexport type { FilterInput } from './FilterInput';\nexport type { FilterKey } from './FilterKey';\nexport type { FilterValue } from './FilterValue';\nexport type { LookupType } from './LookupType';\nexport type { OrderSpec } from './OrderSpec';\nexport type { OrderToken } from './OrderToken';\nexport type { QNode } from './QNode';\nexport type { QueryResult } from './QueryResult';\nexport type { QuerySetState } from './QuerySetState';\nexport type { RelationMeta } from './RelationMeta';\nexport type { RepositoryMeta as RepoMeta } from './RepositoryMeta';\nexport type { WhereClause } from './WhereClause';\n","/**\n * Domain boundary barrel: exposes namespaced exports for Django-style drill-down\n * imports and curated flat exports for TS-native ergonomics.\n */\n\nexport * as compiler from './compiler/index';\nexport * as domain from './domain/index';\n\nexport type * from './domain/index';\nexport type { RepoMeta } from './domain/index';\nexport { QuerySet } from './QuerySet';\nexport type { RepositoryLike } from './QuerySet';\nexport { QBuilder, QBuilder as Q } from './QBuilder';\nexport { QueryCompiler } from './compiler/index';\n"],"mappings":""}

package/dist/repository/Repository.d.ts

@@ -0,0 +1,40 @@
+import type { DBClient } from '../connection/clients/DBClient';
+import { QuerySet } from '../query/QuerySet';
+import type { RepositoryMeta } from '../query/domain/RepositoryMeta';
+/**
+ * Base repository class providing CRUD operations and query building capabilities.
+ * Extend this class to create model-specific repositories with custom business logic.
+ *
+ * @template T - The model type this repository manages
+ *
+ * @example
+ * ```typescript
+ * class UserRepository extends Repository<User> {
+ *   meta = {
+ *     table: 'users',
+ *     pk: 'id',
+ *     columns: { id: 'int', email: 'text', name: 'text' },
+ *   };
+ *
+ *   async findByEmail(email: string): Promise<User | null> {
+ *     return this.query().filter({ email }).fetchOne();
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class Repository<T extends Record<string, unknown>> {
+    static readonly BRAND: "tango.orm.repository";
+    readonly __tangoBrand: typeof Repository.BRAND;
+    abstract meta: RepositoryMeta;
+    protected client: DBClient;
+    protected dialect: 'postgres' | 'sqlite';
+    static isRepository<T extends Record<string, unknown>>(value: unknown): value is Repository<T>;
+    constructor(client: DBClient, dialect?: 'postgres' | 'sqlite');
+    query(): QuerySet<T>;
+    findById(id: T[keyof T]): Promise<T | null>;
+    getOrThrow(id: T[keyof T]): Promise<T>;
+    create(input: Partial<T>): Promise<T>;
+    update(id: T[keyof T], patch: Partial<T>): Promise<T>;
+    delete(id: T[keyof T]): Promise<void>;
+    bulkCreate(inputs: Partial<T>[]): Promise<T[]>;
+}

package/dist/repository/Repository.js

@@ -0,0 +1,100 @@
+import { NotFoundError } from '@danceroutine/tango-core';
+import { QuerySet } from '../query/QuerySet';
+/**
+ * Base repository class providing CRUD operations and query building capabilities.
+ * Extend this class to create model-specific repositories with custom business logic.
+ *
+ * @template T - The model type this repository manages
+ *
+ * @example
+ * ```typescript
+ * class UserRepository extends Repository<User> {
+ *   meta = {
+ *     table: 'users',
+ *     pk: 'id',
+ *     columns: { id: 'int', email: 'text', name: 'text' },
+ *   };
+ *
+ *   async findByEmail(email: string): Promise<User | null> {
+ *     return this.query().filter({ email }).fetchOne();
+ *   }
+ * }
+ * ```
+ */
+export class Repository {
+    static BRAND = 'tango.orm.repository';
+    __tangoBrand = Repository.BRAND;
+    client;
+    dialect;
+    static isRepository(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value.__tangoBrand === Repository.BRAND);
+    }
+    constructor(client, dialect = 'postgres') {
+        this.client = client;
+        this.dialect = dialect;
+    }
+    query() {
+        return new QuerySet({
+            meta: this.meta,
+            client: this.client,
+            dialect: this.dialect,
+            run: async (compiled) => {
+                const result = await this.client.query(compiled.sql, compiled.params);
+                return result.rows;
+            },
+        }, {});
+    }
+    async findById(id) {
+        const filter = { [this.meta.pk]: id };
+        const result = await this.query().filter(filter).fetchOne();
+        return result;
+    }
+    async getOrThrow(id) {
+        const result = await this.findById(id);
+        if (!result) {
+            throw new NotFoundError(`${this.meta.table} with ${this.meta.pk}=${String(id)} not found`);
+        }
+        return result;
+    }
+    async create(input) {
+        const keys = Object.keys(input);
+        const values = Object.values(input);
+        const placeholder = this.dialect === 'postgres' ? keys.map((_, i) => `$${i + 1}`).join(', ') : keys.map(() => '?').join(', ');
+        const sql = `INSERT INTO ${this.meta.table} (${keys.join(', ')}) VALUES (${placeholder}) RETURNING *`;
+        const result = await this.client.query(sql, values);
+        return result.rows[0];
+    }
+    async update(id, patch) {
+        const keys = Object.keys(patch);
+        const values = Object.values(patch);
+        const sets = this.dialect === 'postgres'
+            ? keys.map((k, i) => `${k} = $${i + 1}`).join(', ')
+            : keys.map((k) => `${k} = ?`).join(', ');
+        const whereParam = this.dialect === 'postgres' ? `$${keys.length + 1}` : '?';
+        const sql = `UPDATE ${this.meta.table} SET ${sets} WHERE ${this.meta.pk} = ${whereParam} RETURNING *`;
+        const result = await this.client.query(sql, [...values, id]);
+        return result.rows[0];
+    }
+    async delete(id) {
+        const placeholder = this.dialect === 'postgres' ? '$1' : '?';
+        const sql = `DELETE FROM ${this.meta.table} WHERE ${this.meta.pk} = ${placeholder}`;
+        await this.client.query(sql, [id]);
+    }
+    async bulkCreate(inputs) {
+        if (inputs.length === 0)
+            return [];
+        const keys = Object.keys(inputs[0]);
+        const valueRows = inputs.map((input) => Object.values(input));
+        const placeholders = this.dialect === 'postgres'
+            ? valueRows
+                .map((_, rowIdx) => `(${keys.map((_, colIdx) => `$${rowIdx * keys.length + colIdx + 1}`).join(', ')})`)
+                .join(', ')
+            : valueRows.map(() => `(${keys.map(() => '?').join(', ')})`).join(', ');
+        const sql = `INSERT INTO ${this.meta.table} (${keys.join(', ')}) VALUES ${placeholders} RETURNING *`;
+        const allValues = valueRows.flat();
+        const result = await this.client.query(sql, allValues);
+        return result.rows;
+    }
+}

package/dist/repository/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { Repository } from './Repository';

package/dist/repository/index.js

@@ -0,0 +1,4 @@
+import "../QuerySet-BzR5QzGi.js";
+import { Repository } from "../repository-DaRvsfjs.js";
+
+export { Repository };

package/dist/repository-DaRvsfjs.js

@@ -0,0 +1,78 @@
+import { __export } from "./chunk-DLY2FNSh.js";
+import { QuerySet } from "./QuerySet-BzR5QzGi.js";
+
+//#region src/repository/Repository.ts
+var Repository = class Repository {
+	static BRAND = "tango.orm.repository";
+	__tangoBrand = Repository.BRAND;
+	client;
+	dialect;
+	static isRepository(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === Repository.BRAND;
+	}
+	constructor(client, dialect = "postgres") {
+		this.client = client;
+		this.dialect = dialect;
+	}
+	query() {
+		return new QuerySet({
+			meta: this.meta,
+			client: this.client,
+			dialect: this.dialect,
+			run: async (compiled) => {
+				const result = await this.client.query(compiled.sql, compiled.params);
+				return result.rows;
+			}
+		}, {});
+	}
+	async findById(id) {
+		const result = await this.query().filter({ [this.meta.pk]: id }).fetchOne();
+		return result;
+	}
+	async getOrThrow(id) {
+		const result = await this.findById(id);
+		if (!result) throw new Error(`${this.meta.table} with ${this.meta.pk}=${String(id)} not found`);
+		return result;
+	}
+	async create(input) {
+		const keys = Object.keys(input);
+		const values = Object.values(input);
+		const placeholder = this.dialect === "postgres" ? keys.map((_, i) => `$${i + 1}`).join(", ") : keys.map(() => "?").join(", ");
+		const sql = `INSERT INTO ${this.meta.table} (${keys.join(", ")}) VALUES (${placeholder}) RETURNING *`;
+		const result = await this.client.query(sql, values);
+		return result.rows[0];
+	}
+	async update(id, patch) {
+		const keys = Object.keys(patch);
+		const values = Object.values(patch);
+		const sets = this.dialect === "postgres" ? keys.map((k, i) => `${k} = $${i + 1}`).join(", ") : keys.map((k) => `${k} = ?`).join(", ");
+		const whereParam = this.dialect === "postgres" ? `$${keys.length + 1}` : "?";
+		const sql = `UPDATE ${this.meta.table} SET ${sets} WHERE ${this.meta.pk} = ${whereParam} RETURNING *`;
+		const result = await this.client.query(sql, [...values, id]);
+		return result.rows[0];
+	}
+	async delete(id) {
+		const placeholder = this.dialect === "postgres" ? "$1" : "?";
+		const sql = `DELETE FROM ${this.meta.table} WHERE ${this.meta.pk} = ${placeholder}`;
+		await this.client.query(sql, [id]);
+	}
+	async bulkCreate(inputs) {
+		if (inputs.length === 0) return [];
+		const keys = Object.keys(inputs[0]);
+		const valueRows = inputs.map((input) => Object.values(input));
+		const placeholders = this.dialect === "postgres" ? valueRows.map((_, rowIdx) => `(${keys.map((_$1, colIdx) => `$${rowIdx * keys.length + colIdx + 1}`).join(", ")})`).join(", ") : valueRows.map(() => `(${keys.map(() => "?").join(", ")})`).join(", ");
+		const sql = `INSERT INTO ${this.meta.table} (${keys.join(", ")}) VALUES ${placeholders} RETURNING *`;
+		const allValues = valueRows.flat();
+		const result = await this.client.query(sql, allValues);
+		return result.rows;
+	}
+};
+
+//#endregion
+//#region src/repository/index.ts
+var repository_exports = {};
+__export(repository_exports, { Repository: () => Repository });
+
+//#endregion
+export { Repository, repository_exports };
+//# sourceMappingURL=repository-DaRvsfjs.js.map