@ug.software/opposer 3.0.10

package/lib/cjs/orm/query-builder.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTranslator = void 0;
+const metadata_js_1 = require("./metadata.js");
+class QueryTranslator {
+    constructor(entity, fields, driver) {
+        this.entity = entity;
+        this.fields = fields;
+        this.driver = driver;
+    }
+    validateField(field) {
+        if (field.includes('.')) {
+            const [relationName, ...rest] = field.split('.');
+            const relationField = this.fields.find((f) => f.name === relationName && f.type === 'relation');
+            if (relationField && relationField.relation) {
+                const targetEntity = relationField.relation.target();
+                const targetFields = metadata_js_1.MetadataStore.getFields(targetEntity);
+                const subField = rest.join('.');
+                return this.validateTargetField(targetFields, subField);
+            }
+            return false;
+        }
+        return (this.fields.some((f) => {
+            return f.name === field;
+        }) ||
+            field === 'id' ||
+            field === '*');
+    }
+    validateTargetField(fields, field) {
+        if (field.includes('.')) {
+            const [relationName, ...rest] = field.split('.');
+            const relationField = fields.find((f) => f.name === relationName && f.type === 'relation');
+            if (relationField && relationField.relation) {
+                const targetEntity = relationField.relation.target();
+                const targetFields = metadata_js_1.MetadataStore.getFields(targetEntity);
+                return this.validateTargetField(targetFields, rest.join('.'));
+            }
+            return false;
+        }
+        return fields.some((f) => f.name === field) || field === 'id' || field === '*';
+    }
+    renderFilter(query, params, joins, prefix = '') {
+        if (!query || typeof query !== 'object') {
+            return '';
+        }
+        const parts = [];
+        for (const [key, value] of Object.entries(query)) {
+            if (key === '$or' && Array.isArray(value)) {
+                const orParts = value
+                    .map((v) => {
+                    return this.renderFilter(v, params, joins, prefix);
+                })
+                    .filter((v) => {
+                    return v !== '';
+                })
+                    .map((v) => {
+                    return `(${v})`;
+                });
+                if (orParts.length > 0) {
+                    parts.push(`(${orParts.join(' OR ')})`);
+                }
+                continue;
+            }
+            const fullPath = prefix ? `${prefix}.${key}` : key;
+            if (!this.validateField(fullPath)) {
+                continue;
+            }
+            // If it's a nested object that is NOT an operator ($l, $eq, etc) and NOT a Date,
+            // and it corresponds to a relation, we treat it as a nested filter.
+            const isOperator = typeof key === 'string' && key.startsWith('$');
+            const isNestedFilter = typeof value === 'object' &&
+                value !== null &&
+                !(value instanceof Date) &&
+                !Object.keys(value).some(k => k.startsWith('$'));
+            if (isNestedFilter) {
+                // It's a nested filter (e.g., { author: { name: "..." } })
+                joins.add(key); // Ensure the join is added for this level
+                const nestedFilter = this.renderFilter(value, params, joins, fullPath);
+                if (nestedFilter) {
+                    parts.push(nestedFilter);
+                }
+                continue;
+            }
+            if (fullPath.includes('.')) {
+                const [relationName] = fullPath.split('.');
+                joins.add(relationName);
+            }
+            if (typeof value === 'object' && value !== null && !(value instanceof Date)) {
+                for (const [op, val] of Object.entries(value)) {
+                    const operatorSql = this.renderOperator(fullPath, op, val, params);
+                    if (operatorSql) {
+                        parts.push(operatorSql);
+                    }
+                }
+            }
+            else {
+                params.push(value);
+                parts.push(`${this.quoteField(fullPath)} = $${params.length}`);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    translateFilter(query) {
+        const params = [];
+        const joins = new Set();
+        const sql = this.renderFilter(query, params, joins);
+        return { sql: sql ? `WHERE ${sql}` : '', params, joins };
+    }
+    quoteField(field) {
+        if (field.includes('.')) {
+            return field
+                .split('.')
+                .map((p) => this.driver.quoteIdentifier(p))
+                .join('.');
+        }
+        return `${this.driver.quoteIdentifier(this.entity.tableName)}.${this.driver.quoteIdentifier(field)}`;
+    }
+    renderOperator(column, op, val, params) {
+        const quotedColumn = this.quoteField(column);
+        switch (op) {
+            case '$l':
+                params.push(val);
+                return `${quotedColumn} LIKE $${params.length}`;
+            case '$il':
+                params.push(val);
+                return `${quotedColumn} ILIKE $${params.length}`;
+            case '$in':
+            case '$nin': {
+                if (!Array.isArray(val) || val.length === 0) {
+                    return '';
+                }
+                const placeholders = val
+                    .map((v) => {
+                    params.push(v);
+                    return `$${params.length}`;
+                })
+                    .join(', ');
+                const operator = op === '$in' ? 'IN' : 'NOT IN';
+                return `${quotedColumn} ${operator} (${placeholders})`;
+            }
+            case '$btw':
+                if (!Array.isArray(val) || val.length < 2) {
+                    return '';
+                }
+                params.push(val[0]);
+                params.push(val[1]);
+                return `${quotedColumn} BETWEEN $${params.length - 1} AND $${params.length}`;
+            case '$mt':
+                params.push(val);
+                return `${quotedColumn} > $${params.length}`;
+            case '$mte':
+                params.push(val);
+                return `${quotedColumn} >= $${params.length}`;
+            case '$lt':
+                params.push(val);
+                return `${quotedColumn} < $${params.length}`;
+            case '$lte':
+                params.push(val);
+                return `${quotedColumn} <= $${params.length}`;
+            case '$eq':
+                params.push(val);
+                return `${quotedColumn} = $${params.length}`;
+            default:
+                return '';
+        }
+    }
+    translateSelect(select) {
+        const table = this.driver.quoteIdentifier(this.entity.tableName);
+        if (!select || select.length === 0) {
+            return `${table}.*`;
+        }
+        return select
+            .filter((s) => {
+            return this.validateField(s);
+        })
+            .map((s) => {
+            return this.quoteField(s);
+        })
+            .join(', ');
+    }
+    translateRelations(relations) {
+        const select = [];
+        const joins = [];
+        for (const rel of relations) {
+            const relationName = typeof rel === 'string' ? rel : rel.model;
+            const relationField = this.fields.find((f) => f.name === relationName && f.type === 'relation');
+            if (!relationField) {
+                throw new Error(`Relation '${relationName}' not found on model '${this.entity.name}'`);
+            }
+            if (relationField.relation) {
+                const targetEntity = relationField.relation.target();
+                const targetMetadata = metadata_js_1.MetadataStore.getEntity(targetEntity);
+                const targetFields = metadata_js_1.MetadataStore.getFields(targetEntity);
+                if (targetMetadata) {
+                    const targetTable = this.driver.quoteIdentifier(targetMetadata.tableName);
+                    const relationAlias = this.driver.quoteIdentifier(relationName);
+                    const sourceTable = this.driver.quoteIdentifier(this.entity.tableName);
+                    // Determine join columns
+                    const targetPrimary = targetFields.find(f => f.primary);
+                    const targetPrimaryKeyName = targetPrimary ? targetPrimary.name : 'id';
+                    let joinCondition = '';
+                    if (relationField.relation.type === 'many-to-one' || (relationField.relation.type === 'one-to-one' && relationField.relation.joinColumn)) {
+                        joinCondition = `${sourceTable}.${this.driver.quoteIdentifier(relationName)} = ${relationAlias}.${this.driver.quoteIdentifier(targetPrimaryKeyName)}`;
+                    }
+                    else if (relationField.relation.type === 'one-to-many' || (relationField.relation.type === 'one-to-one' && !relationField.relation.joinColumn)) {
+                        const inverseSide = relationField.relation.inverseSide;
+                        if (inverseSide) {
+                            joinCondition = `${relationAlias}.${this.driver.quoteIdentifier(inverseSide)} = ${sourceTable}.id`;
+                        }
+                    }
+                    if (joinCondition) {
+                        joins.push(`LEFT JOIN ${targetTable} AS ${relationAlias} ON ${joinCondition}`);
+                        const selectedFields = typeof rel === 'object' && rel.select ? rel.select : ['*'];
+                        const targetPrimaryFields = targetFields.filter(f => f.primary);
+                        // Always ensure primary keys are included for hydration
+                        for (const pf of targetPrimaryFields) {
+                            if (!selectedFields.includes(pf.name) && !selectedFields.includes('*')) {
+                                select.push(`${relationAlias}.${this.driver.quoteIdentifier(pf.name)} AS ${this.driver.quoteIdentifier(`${relationName}.${pf.name}`)}`);
+                            }
+                        }
+                        for (const f of selectedFields) {
+                            if (typeof f === 'string') {
+                                if (f === '*') {
+                                    for (const tf of targetFields) {
+                                        if (tf.type !== 'relation') {
+                                            select.push(`${relationAlias}.${this.driver.quoteIdentifier(tf.name)} AS ${this.driver.quoteIdentifier(`${relationName}.${tf.name}`)}`);
+                                        }
+                                    }
+                                    // Also include 'id' if not in targetFields
+                                    if (!targetFields.some(tf => tf.name === 'id')) {
+                                        select.push(`${relationAlias}.id AS ${this.driver.quoteIdentifier(`${relationName}.id`)}`);
+                                    }
+                                }
+                                else {
+                                    select.push(`${relationAlias}.${this.driver.quoteIdentifier(f)} AS ${this.driver.quoteIdentifier(`${relationName}.${f}`)}`);
+                                }
+                            }
+                            // TODO: nested relations
+                        }
+                    }
+                }
+            }
+        }
+        return { select, joins };
+    }
+    translateAggregate(aggregates) {
+        return Object.entries(aggregates)
+            .map(([field, op]) => {
+            const quotedField = field === '*' ? '*' : this.quoteField(field);
+            const alias = this.driver.quoteIdentifier(`${op}_${field.replace('*', 'all').replace('.', '_')}`);
+            return `${op.toUpperCase()}(${quotedField}) as ${alias}`;
+        })
+            .join(', ');
+    }
+    translateGroup(fields) {
+        if (!fields || fields.length === 0) {
+            return '';
+        }
+        const quotedFields = fields
+            .filter((f) => {
+            return this.validateField(f);
+        })
+            .map((f) => {
+            return this.quoteField(f);
+        })
+            .join(', ');
+        return quotedFields ? `GROUP BY ${quotedFields}` : '';
+    }
+    translatePagination(pagination) {
+        if (!pagination) {
+            return '';
+        }
+        const limit = Math.max(0, pagination.take || 10);
+        const offset = Math.max(0, pagination.page || 0) * limit;
+        return `LIMIT ${limit} OFFSET ${offset}`;
+    }
+}
+exports.QueryTranslator = QueryTranslator;

package/lib/cjs/orm/repository.d.ts

@@ -0,0 +1,54 @@
+import { OpposerDatabase } from './opposer.js';
+import { EntityMetadata, FieldMetadata } from './metadata.js';
+import { QueryBuilder as OpposerQueryBuilder, RelationBuilder } from '../interfaces/controller.js';
+export declare class Repository<T> {
+    private connection;
+    private target;
+    private metadata;
+    private fields;
+    private translator;
+    constructor(connection: OpposerDatabase, target: Function);
+    get Metadata(): EntityMetadata;
+    get Fields(): FieldMetadata[];
+    find(options: {
+        where?: OpposerQueryBuilder;
+        select?: string[];
+        pagination?: {
+            page: number;
+            take: number;
+        };
+        relation?: (string | RelationBuilder)[];
+    }): Promise<T[]>;
+    findOne(options: {
+        where?: OpposerQueryBuilder;
+        select?: string[];
+        relation?: (string | RelationBuilder)[];
+    }): Promise<T | null>;
+    private reconstruct;
+    private merge;
+    private executeHooks;
+    insert(data: Partial<T>): Promise<T>;
+    update(where: OpposerQueryBuilder, data: Partial<T>): Promise<void>;
+    delete(where: OpposerQueryBuilder): Promise<void>;
+    count(where: OpposerQueryBuilder): Promise<number>;
+    exists(where: OpposerQueryBuilder): Promise<boolean>;
+    aggregate(options: {
+        where?: OpposerQueryBuilder;
+        aggregate: {
+            [key: string]: 'sum' | 'avg' | 'min' | 'max' | 'count';
+        };
+    }): Promise<any>;
+    distinct(options: {
+        where?: OpposerQueryBuilder;
+        field: string;
+    }): Promise<any[]>;
+    group(options: {
+        where?: OpposerQueryBuilder;
+        by: string[];
+        aggregate?: {
+            [key: string]: 'sum' | 'avg' | 'min' | 'max' | 'count';
+        };
+        select?: string[];
+    }): Promise<any[]>;
+    validate(data: Partial<T>): Record<string, string[]>;
+}

package/lib/cjs/orm/repository.js

@@ -0,0 +1,325 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = void 0;
+const metadata_js_1 = require("./metadata.js");
+const query_builder_js_1 = require("./query-builder.js");
+const crypto_1 = __importDefault(require("crypto"));
+class Repository {
+    constructor(connection, target) {
+        this.connection = connection;
+        this.target = target;
+        const metadata = metadata_js_1.MetadataStore.getEntity(target);
+        const fields = metadata_js_1.MetadataStore.getFields(target);
+        if (!metadata) {
+            throw new Error(`Entity metadata not found for ${target.name}`);
+        }
+        this.metadata = metadata;
+        this.fields = fields;
+        this.translator = new query_builder_js_1.QueryTranslator(this.metadata, this.fields, this.connection.getDriver());
+    }
+    get Metadata() {
+        return this.metadata;
+    }
+    get Fields() {
+        return this.fields;
+    }
+    async find(options) {
+        const driver = this.connection.getDriver();
+        const selectParts = [];
+        // Main entity select
+        selectParts.push(this.translator.translateSelect(options.select || []));
+        // Relations
+        const relationResult = this.translator.translateRelations(options.relation || []);
+        if (relationResult.select.length > 0) {
+            selectParts.push(...relationResult.select);
+        }
+        const { sql: where, params, joins: whereJoins } = this.translator.translateFilter(options.where || {});
+        const pagination = this.translator.translatePagination(options.pagination);
+        const allJoins = new Set(relationResult.joins);
+        // Add missing joins from where clause
+        if (whereJoins.size > 0) {
+            const neededJoins = Array.from(whereJoins);
+            // We need to translate these joins if they are not already in allJoins
+            // For simplicity, let's assume translateRelations can be called for individual relations
+            const missingJoinsResult = this.translator.translateRelations(neededJoins.filter(rj => !options.relation?.some(r => (typeof r === 'string' ? r === rj : r.model === rj))));
+            missingJoinsResult.joins.forEach(j => allJoins.add(j));
+        }
+        const joinsSql = Array.from(allJoins).join(' ');
+        const sql = `SELECT ${selectParts.join(', ')} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${joinsSql} ${where} ${pagination};`;
+        const results = await driver.query(sql, params);
+        const primaryFields = this.fields.filter((f) => f.primary);
+        const entitiesMap = new Map();
+        for (const row of results) {
+            const pk = primaryFields.map((f) => row[f.name]).join(':');
+            if (!entitiesMap.has(pk)) {
+                entitiesMap.set(pk, this.reconstruct(row));
+            }
+            else {
+                const existing = entitiesMap.get(pk);
+                this.merge(existing, row);
+            }
+        }
+        return Array.from(entitiesMap.values());
+    }
+    async findOne(options) {
+        const results = await this.find({
+            ...options,
+            pagination: { page: 0, take: 1 },
+        });
+        return results.length > 0 ? results[0] : null;
+    }
+    reconstruct(row) {
+        const entity = new this.target();
+        this.merge(entity, row);
+        return entity;
+    }
+    merge(entity, row) {
+        for (const [key, value] of Object.entries(row)) {
+            if (key.includes('.')) {
+                const parts = key.split('.');
+                let current = entity;
+                let currentTarget = this.target;
+                for (let i = 0; i < parts.length - 1; i++) {
+                    const part = parts[i];
+                    const relationField = metadata_js_1.MetadataStore.getFields(currentTarget).find((f) => f.name === part);
+                    if (relationField && relationField.relation) {
+                        const isArray = relationField.relation.type === 'one-to-many' || relationField.relation.type === 'many-to-many';
+                        const nextTarget = relationField.relation.target();
+                        if (isArray) {
+                            if (!Array.isArray(current[part])) {
+                                current[part] = [];
+                            }
+                            // We need to find if the item already exists in the array
+                            // To do that we need the primary key of the target entity
+                            const targetFields = metadata_js_1.MetadataStore.getFields(nextTarget);
+                            const targetPrimaryFields = targetFields.filter(f => f.primary);
+                            // Find child row values for child PK
+                            const childPkValues = {};
+                            let hasAnyValue = false;
+                            targetPrimaryFields.forEach(pf => {
+                                const fullKey = [...parts.slice(0, i + 1), pf.name].join('.');
+                                if (row[fullKey] !== undefined && row[fullKey] !== null) {
+                                    childPkValues[pf.name] = row[fullKey];
+                                    hasAnyValue = true;
+                                }
+                            });
+                            if (!hasAnyValue) {
+                                // If all PK fields of the relation are null, it means there's no related record (LEFT JOIN result)
+                                break;
+                            }
+                            let existingChild = current[part].find((item) => {
+                                return targetPrimaryFields.every(pf => item[pf.name] === childPkValues[pf.name]);
+                            });
+                            if (!existingChild) {
+                                existingChild = new nextTarget();
+                                current[part].push(existingChild);
+                            }
+                            current = existingChild;
+                            currentTarget = nextTarget;
+                        }
+                        else {
+                            if (typeof current[part] === 'string' || current[part] === undefined || current[part] === null) {
+                                const id = typeof current[part] === 'string' ? current[part] : undefined;
+                                current[part] = id ? { id } : new nextTarget();
+                            }
+                            current = current[part];
+                            currentTarget = nextTarget;
+                        }
+                    }
+                    else {
+                        // Fallback for non-metadata relations (should not happen with decorators)
+                        if (current[part] === undefined || current[part] === null) {
+                            current[part] = {};
+                        }
+                        current = current[part];
+                    }
+                }
+                const lastPart = parts[parts.length - 1];
+                if (value !== null || current[lastPart] === undefined) {
+                    current[lastPart] = value;
+                }
+            }
+            else {
+                if (value === null && typeof entity[key] === 'object' && entity[key] !== null) {
+                    continue;
+                }
+                entity[key] = value;
+            }
+        }
+    }
+    async executeHooks(type, entity) {
+        const hooks = metadata_js_1.MetadataStore.getHooks(this.target).filter((h) => {
+            return h.type === type;
+        });
+        for (const hook of hooks) {
+            const method = entity[hook.propertyKey];
+            if (typeof method === 'function') {
+                await method.apply(entity);
+            }
+        }
+    }
+    async insert(data) {
+        const entity = Object.assign(new this.target(), data);
+        // Execute hooks
+        await this.executeHooks('before-insert', entity);
+        const persistableFields = metadata_js_1.MetadataStore.getPersistableFields(this.target);
+        const now = new Date();
+        for (const field of persistableFields) {
+            if (field.createDate || field.updateDate) {
+                if (entity[field.name] === undefined) {
+                    entity[field.name] = now;
+                }
+            }
+            if (field.generated && field.type === 'uuid' && entity[field.name] === undefined) {
+                entity[field.name] = crypto_1.default.randomUUID();
+            }
+        }
+        const persistableKeys = persistableFields.map((f) => {
+            return f.name;
+        });
+        const keys = Object.keys(entity).filter((k) => {
+            return persistableKeys.includes(k) || k === 'id';
+        });
+        const values = keys.map((k) => {
+            return entity[k];
+        });
+        const driver = this.connection.getDriver();
+        const placeholders = keys
+            .map((_, i) => {
+            return `$${i + 1}`;
+        })
+            .join(', ');
+        const columns = keys
+            .map((k) => {
+            return driver.quoteIdentifier(k);
+        })
+            .join(', ');
+        const isSqlite = driver.constructor.name === 'SQLiteDriver';
+        if (isSqlite) {
+            const sql = `INSERT INTO ${driver.quoteIdentifier(this.metadata.tableName)} (${columns}) VALUES (${placeholders});`;
+            await driver.query(sql, values);
+            // Fetch the inserted record using primary key(s)
+            const primaryFields = this.fields.filter((f) => {
+                return f.primary;
+            });
+            const where = {};
+            primaryFields.forEach((f) => {
+                where[f.name] = entity[f.name];
+            });
+            return (await this.findOne({ where }));
+        }
+        else {
+            const sql = `INSERT INTO ${driver.quoteIdentifier(this.metadata.tableName)} (${columns}) VALUES (${placeholders}) RETURNING *;`;
+            const result = await driver.query(sql, values);
+            return result[0];
+        }
+    }
+    async update(where, data) {
+        const entity = Object.assign(new this.target(), data);
+        await this.executeHooks('before-update', entity);
+        const persistableFields = metadata_js_1.MetadataStore.getPersistableFields(this.target);
+        const now = new Date();
+        for (const field of persistableFields) {
+            if (field.updateDate) {
+                entity[field.name] = now;
+            }
+        }
+        const driver = this.connection.getDriver();
+        const persistableKeys = persistableFields.map((f) => {
+            return f.name;
+        });
+        const setKeys = Object.keys(entity).filter((k) => {
+            return persistableKeys.includes(k);
+        });
+        const setValues = setKeys.map((k) => {
+            return entity[k];
+        });
+        const setSql = setKeys
+            .map((k, i) => {
+            return `${driver.quoteIdentifier(k)} = $${i + 1}`;
+        })
+            .join(', ');
+        const { sql: whereSql, params: whereParams } = this.translator.translateFilter(where);
+        // Adjust whereParams placeholders
+        const adjustedWhereSql = whereSql.replace(/\$(\d+)/g, (_, n) => {
+            return `$${parseInt(n) + setValues.length}`;
+        });
+        const sql = `UPDATE ${driver.quoteIdentifier(this.metadata.tableName)} SET ${setSql} ${adjustedWhereSql};`;
+        await driver.query(sql, [...setValues, ...whereParams]);
+    }
+    async delete(where) {
+        const driver = this.connection.getDriver();
+        const { sql: whereSql, params } = this.translator.translateFilter(where);
+        const sql = `DELETE FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
+        await driver.query(sql, params);
+    }
+    async count(where) {
+        const driver = this.connection.getDriver();
+        const { sql: whereSql, params } = this.translator.translateFilter(where);
+        const sql = `SELECT COUNT(*) as count FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
+        const result = await driver.query(sql, params);
+        return parseInt(result[0].count);
+    }
+    async exists(where) {
+        const driver = this.connection.getDriver();
+        const { sql: whereSql, params } = this.translator.translateFilter(where);
+        const sql = `SELECT 1 FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql} LIMIT 1;`;
+        const result = await driver.query(sql, params);
+        return result.length > 0;
+    }
+    async aggregate(options) {
+        const driver = this.connection.getDriver();
+        const { sql: whereSql, params } = this.translator.translateFilter(options.where || {});
+        const aggregateSql = this.translator.translateAggregate(options.aggregate);
+        const sql = `SELECT ${aggregateSql} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
+        const result = await driver.query(sql, params);
+        return result[0];
+    }
+    async distinct(options) {
+        const driver = this.connection.getDriver();
+        const { sql: whereSql, params } = this.translator.translateFilter(options.where || {});
+        const sql = `SELECT DISTINCT ${driver.quoteIdentifier(options.field)} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql};`;
+        const result = await driver.query(sql, params);
+        return result.map((r) => {
+            return r[options.field];
+        });
+    }
+    async group(options) {
+        const driver = this.connection.getDriver();
+        const { sql: whereSql, params } = this.translator.translateFilter(options.where || {});
+        const groupSql = this.translator.translateGroup(options.by);
+        let selectParts = [];
+        if (options.select) {
+            selectParts.push(this.translator.translateSelect(options.select));
+        }
+        else {
+            selectParts.push(options.by
+                .map((f) => {
+                return driver.quoteIdentifier(f);
+            })
+                .join(', '));
+        }
+        if (options.aggregate) {
+            selectParts.push(this.translator.translateAggregate(options.aggregate));
+        }
+        const sql = `SELECT ${selectParts.join(', ')} FROM ${driver.quoteIdentifier(this.metadata.tableName)} ${whereSql} ${groupSql};`;
+        return await driver.query(sql, params);
+    }
+    validate(data) {
+        const errors = {};
+        for (const field of this.fields) {
+            if (field.validation) {
+                const val = field.validation();
+                const fieldErrors = val.validate(data[field.name], data);
+                if (fieldErrors && fieldErrors.length > 0) {
+                    errors[field.name] = fieldErrors;
+                }
+            }
+        }
+        return errors;
+    }
+}
+exports.Repository = Repository;