@uql/core 1.0.12 → 3.0.0

package/dist/dialect/index.d.ts

@@ -0,0 +1,3 @@
+export * from './abstractDialect.js';
+export * from './abstractSqlDialect.js';
+export * from './queryContext.js';

package/dist/dialect/index.js

@@ -0,0 +1,4 @@
+export * from './abstractDialect.js';
+export * from './abstractSqlDialect.js';
+export * from './queryContext.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZGlhbGVjdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3REaWFsZWN0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3RTcWxEaWFsZWN0LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnlDb250ZXh0LmpzJztcbiJdfQ==

package/dist/dialect/queryContext.d.ts

@@ -0,0 +1,48 @@
+import type { QueryContext, QueryDialect } from '../type/index.js';
+/**
+ * SqlQueryContext is an implementation of the QueryContext interface specifically for SQL-based dialects.
+ * It follows the "Accumulator" or "Builder" pattern to construct SQL queries and their corresponding parameters.
+ *
+ * This pattern solves the problem of building complex SQL strings while safely managing parameterized values,
+ * preventing SQL injection and handling dialect-specific parameter placeholders (e.g., '?' for MySQL, '$n' for PostgreSQL).
+ */
+export declare class SqlQueryContext implements QueryContext {
+    readonly dialect: QueryDialect;
+    private readonly sqlChunks;
+    private readonly params;
+    /**
+     * @param dialect The SQL dialect used to determine how values should be formatted as placeholders.
+     */
+    constructor(dialect: QueryDialect);
+    /**
+     * Appends raw SQL string fragments to the query.
+     *
+     * @param sql The SQL fragment to append.
+     * @returns The current context instance for method chaining.
+     */
+    append(sql: string): this;
+    /**
+     * Adds a value to the query parameters and appends its corresponding placeholder to the SQL.
+     * The placeholder format is determined by the dialect (e.g., '?' or '$1').
+     *
+     * @param value The value to be parameterized.
+     * @returns The current context instance for method chaining.
+     */
+    addValue(value: unknown): this;
+    /**
+     * Pushes a value to the parameters list without appending a placeholder to the SQL.
+     * This is useful when the placeholder is already present in the SQL string or handled elsewhere.
+     *
+     * @param value The value to be added to the parameters.
+     * @returns The current context instance for method chaining.
+     */
+    pushValue(value: unknown): this;
+    /**
+     * Returns the complete SQL query string by joining all accumulated chunks.
+     */
+    get sql(): string;
+    /**
+     * Returns the array of collected parameter values in the order they were added.
+     */
+    get values(): unknown[];
+}

package/dist/dialect/queryContext.js

@@ -0,0 +1,65 @@
+/**
+ * SqlQueryContext is an implementation of the QueryContext interface specifically for SQL-based dialects.
+ * It follows the "Accumulator" or "Builder" pattern to construct SQL queries and their corresponding parameters.
+ *
+ * This pattern solves the problem of building complex SQL strings while safely managing parameterized values,
+ * preventing SQL injection and handling dialect-specific parameter placeholders (e.g., '?' for MySQL, '$n' for PostgreSQL).
+ */
+export class SqlQueryContext {
+    dialect;
+    sqlChunks = [];
+    params = [];
+    /**
+     * @param dialect The SQL dialect used to determine how values should be formatted as placeholders.
+     */
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    /**
+     * Appends raw SQL string fragments to the query.
+     *
+     * @param sql The SQL fragment to append.
+     * @returns The current context instance for method chaining.
+     */
+    append(sql) {
+        if (sql) {
+            this.sqlChunks.push(sql);
+        }
+        return this;
+    }
+    /**
+     * Adds a value to the query parameters and appends its corresponding placeholder to the SQL.
+     * The placeholder format is determined by the dialect (e.g., '?' or '$1').
+     *
+     * @param value The value to be parameterized.
+     * @returns The current context instance for method chaining.
+     */
+    addValue(value) {
+        this.sqlChunks.push(this.dialect.addValue(this.params, value));
+        return this;
+    }
+    /**
+     * Pushes a value to the parameters list without appending a placeholder to the SQL.
+     * This is useful when the placeholder is already present in the SQL string or handled elsewhere.
+     *
+     * @param value The value to be added to the parameters.
+     * @returns The current context instance for method chaining.
+     */
+    pushValue(value) {
+        this.params.push(value);
+        return this;
+    }
+    /**
+     * Returns the complete SQL query string by joining all accumulated chunks.
+     */
+    get sql() {
+        return this.sqlChunks.join('');
+    }
+    /**
+     * Returns the array of collected parameter values in the order they were added.
+     */
+    get values() {
+        return this.params;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{entity → dist/entity}/decorator/definition.d.ts

@@ -1,9 +1,9 @@
 import 'reflect-metadata';
-import { RelationOptions, FieldOptions, EntityOptions, EntityMeta, Type } from '../../type';
+import type { EntityMeta, EntityOptions, FieldOptions, RelationOptions, Type } from '../../type/index.js';
 export declare function defineField<E>(entity: Type<E>, key: string, opts?: FieldOptions): EntityMeta<E>;
 export declare function defineId<E>(entity: Type<E>, key: string, opts: FieldOptions): EntityMeta<E>;
 export declare function defineRelation<E>(entity: Type<E>, key: string, opts: RelationOptions<E>): EntityMeta<E>;
 export declare function defineEntity<E>(entity: Type<E>, opts?: EntityOptions): EntityMeta<E>;
-export declare function getEntities(): Type<any>[];
+export declare function getEntities(): Type<unknown>[];
 export declare function getMeta<E>(entity: Type<E>): EntityMeta<E>;
-export declare function isValidEntityType(type: any): type is Type<any>;
+export declare function isValidEntityType(type: unknown): type is Type<unknown>;

package/dist/entity/decorator/definition.js

@@ -0,0 +1,214 @@
+import 'reflect-metadata';
+import { getKeys, hasKeys, lowerFirst, upperFirst } from '../../util/index.js';
+const holder = globalThis;
+const metaKey = '@uql/core/entity/decorator';
+const metas = holder[metaKey] ?? new Map();
+holder[metaKey] = metas;
+export function defineField(entity, key, opts = {}) {
+    const meta = ensureMeta(entity);
+    if (!opts.type) {
+        const type = inferType(entity, key);
+        opts = { ...opts, type };
+    }
+    meta.fields[key] = { ...meta.fields[key], ...{ name: key, ...opts } };
+    return meta;
+}
+export function defineId(entity, key, opts) {
+    const meta = ensureMeta(entity);
+    const id = getIdKey(meta);
+    if (id) {
+        console.info(`Overriding ID property for '${entity.name}' from '${id}' to '${key}'`);
+        delete meta.fields[id];
+    }
+    return defineField(entity, key, { ...opts, isId: true });
+}
+export function defineRelation(entity, key, opts) {
+    if (!opts.entity) {
+        const inferredType = inferEntityType(entity, key);
+        opts.entity = () => inferredType;
+    }
+    const meta = ensureMeta(entity);
+    meta.relations[key] = { ...meta.relations[key], ...opts };
+    return meta;
+}
+export function defineEntity(entity, opts = {}) {
+    const meta = ensureMeta(entity);
+    if (!hasKeys(meta.fields)) {
+        throw TypeError(`'${entity.name}' must have fields`);
+    }
+    const onDeleteKeys = getKeys(meta.fields).filter((key) => meta.fields[key].onDelete);
+    if (onDeleteKeys.length > 1) {
+        throw TypeError(`'${entity.name}' must have one field with 'onDelete' as maximum`);
+    }
+    if (opts.softDelete) {
+        if (!onDeleteKeys.length) {
+            throw TypeError(`'${entity.name}' must have one field with 'onDelete' to enable 'softDelete'`);
+        }
+        meta.softDelete = onDeleteKeys[0];
+    }
+    meta.name = opts.name ?? entity.name;
+    let proto = Object.getPrototypeOf(entity.prototype);
+    while (proto.constructor !== Object) {
+        const parentMeta = ensureMeta(proto.constructor);
+        extendMeta(meta, parentMeta);
+        proto = Object.getPrototypeOf(proto);
+    }
+    const id = getIdKey(meta);
+    if (!id) {
+        throw TypeError(`'${entity.name}' must have one field decorated with @Id`);
+    }
+    meta.id = id;
+    return meta;
+}
+export function getEntities() {
+    return [...metas.entries()].reduce((acc, [key, val]) => {
+        if (val.id) {
+            acc.push(key);
+        }
+        return acc;
+    }, []);
+}
+function ensureMeta(entity) {
+    let meta = metas.get(entity);
+    if (meta) {
+        return meta;
+    }
+    meta = { entity, fields: {}, relations: {} };
+    metas.set(entity, meta);
+    return meta;
+}
+export function getMeta(entity) {
+    const meta = metas.get(entity);
+    if (!meta) {
+        throw TypeError(`'${entity.name}' is not an entity`);
+    }
+    if (meta.processed) {
+        return meta;
+    }
+    meta.processed = true;
+    return fillRelations(meta);
+}
+function fillRelations(meta) {
+    for (const relKey in meta.relations) {
+        const relOpts = meta.relations[relKey];
+        if (relOpts.references) {
+            // references were manually specified
+            continue;
+        }
+        if (relOpts.mappedBy) {
+            fillInverseSideRelations(relOpts);
+            continue;
+        }
+        const relEntity = relOpts.entity();
+        const relMeta = ensureMeta(relEntity);
+        if (relOpts.cardinality === 'mm') {
+            const idName = meta.fields[meta.id].name;
+            const relIdName = relMeta.fields[relMeta.id].name;
+            const source = lowerFirst(meta.name) + upperFirst(idName);
+            const target = lowerFirst(relMeta.name) + upperFirst(relIdName);
+            relOpts.references = [
+                { local: source, foreign: meta.id },
+                { local: target, foreign: relMeta.id },
+            ];
+        }
+        else {
+            relOpts.references = [{ local: `${relKey}Id`, foreign: relMeta.id }];
+        }
+        if (relOpts.through) {
+            fillThroughRelations(relOpts.through());
+        }
+    }
+    return meta;
+}
+function fillInverseSideRelations(relOpts) {
+    const relEntity = relOpts.entity();
+    const relMeta = getMeta(relEntity);
+    relOpts.mappedBy = getMappedByRelationKey(relOpts);
+    if (relMeta.fields[relOpts.mappedBy]) {
+        relOpts.references = [{ local: relMeta.id, foreign: relOpts.mappedBy }];
+        return;
+    }
+    const mappedByRelation = relMeta.relations[relOpts.mappedBy];
+    if (relOpts.cardinality === 'm1' || relOpts.cardinality === 'mm') {
+        relOpts.references = mappedByRelation.references.slice().reverse();
+        relOpts.through = mappedByRelation.through;
+        return;
+    }
+    relOpts.references = mappedByRelation.references.map(({ local, foreign }) => ({
+        local: foreign,
+        foreign: local,
+    }));
+}
+function fillThroughRelations(entity) {
+    const meta = ensureMeta(entity);
+    meta.relations = getKeys(meta.fields).reduce((relations, key) => {
+        const { reference } = meta.fields[key];
+        if (reference) {
+            const relEntity = reference();
+            const relMeta = ensureMeta(relEntity);
+            const relKey = key.slice(0, -relMeta.id.length);
+            const relOpts = {
+                entity: reference,
+                cardinality: 'm1',
+                references: [{ local: key, foreign: relMeta.id }],
+            };
+            relations[relKey] = relOpts;
+        }
+        return relations;
+    }, {});
+}
+function getMappedByRelationKey(relOpts) {
+    if (typeof relOpts.mappedBy === 'function') {
+        const relEntity = relOpts.entity();
+        const relMeta = ensureMeta(relEntity);
+        const keyMap = getRelationKeyMap(relMeta);
+        return relOpts.mappedBy(keyMap);
+    }
+    return relOpts.mappedBy;
+}
+function getRelationKeyMap(meta) {
+    return getKeys(meta.fields)
+        .concat(getKeys(meta.relations))
+        .reduce((acc, key) => {
+        acc[key] = key;
+        return acc;
+    }, {});
+}
+function getIdKey(meta) {
+    const id = getKeys(meta.fields).find((key) => meta.fields[key]?.isId);
+    return id;
+}
+function extendMeta(target, source) {
+    const sourceFields = { ...source.fields };
+    const targetId = getIdKey(target);
+    if (targetId) {
+        const sourceId = getIdKey(source);
+        if (sourceId) {
+            delete sourceFields[sourceId];
+        }
+    }
+    target.fields = { ...sourceFields, ...target.fields };
+    target.relations = { ...source.relations, ...target.relations };
+}
+function inferType(entity, key) {
+    return Reflect.getMetadata('design:type', entity.prototype, key);
+}
+function inferEntityType(entity, key) {
+    const inferredType = inferType(entity, key);
+    const isValidType = isValidEntityType(inferredType);
+    if (!isValidType) {
+        console.log('****', entity, key, inferredType);
+        throw TypeError(`'${entity.name}.${key}' type was auto-inferred with invalid type '${inferredType?.name}'`);
+    }
+    return inferredType;
+}
+export function isValidEntityType(type) {
+    return (typeof type === 'function' &&
+        type !== Boolean &&
+        type !== String &&
+        type !== Number &&
+        type !== BigInt &&
+        type !== Date &&
+        type !== Symbol);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"definition.js","sourceRoot":"","sources":["../../../src/entity/decorator/definition.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAa1B,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE/E,MAAM,MAAM,GAAG,UAAU,CAAC;AAC1B,MAAM,OAAO,GAAG,4BAA4B,CAAC;AAC7C,MAAM,KAAK,GAAwC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,GAAG,EAAE,CAAC;AAChF,MAAM,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC;AAExB,MAAM,UAAU,WAAW,CAAI,MAAe,EAAE,GAAW,EAAE,OAAqB,EAAE;IAClF,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACf,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACpC,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,CAAC;IAC3B,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,CAAC;IACtE,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,QAAQ,CAAI,MAAe,EAAE,GAAW,EAAE,IAAkB;IAC1E,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,EAAE,EAAE,CAAC;QACP,OAAO,CAAC,IAAI,CAAC,+BAA+B,MAAM,CAAC,IAAI,WAAW,EAAE,SAAS,GAAG,GAAG,CAAC,CAAC;QACrF,OAAO,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,WAAW,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;AAC3D,CAAC;AAED,MAAM,UAAU,cAAc,CAAI,MAAe,EAAE,GAAW,EAAE,IAAwB;IACtF,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;QACjB,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClD,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC;IACnC,CAAC;IACD,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC;IAC1D,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,YAAY,CAAI,MAAe,EAAE,OAAsB,EAAE;IACvE,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAEhC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;QAC1B,MAAM,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,oBAAoB,CAAC,CAAC;IACvD,CAAC;IAED,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAkB,CAAC;IAEtG,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC5B,MAAM,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,kDAAkD,CAAC,CAAC;IACrF,CAAC;IAED,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;QACpB,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;YACzB,MAAM,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,8DAA8D,CAAC,CAAC;QACjG,CAAC;QACD,IAAI,CAAC,UAAU,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC;IACrC,IAAI,KAAK,GAAwB,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAEzE,OAAO,KAAK,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;QACpC,MAAM,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,WAAsB,CAAC,CAAC;QAC5D,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC7B,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IACvC,CAAC;IAED,MAAM,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,MAAM,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,0CAA0C,CAAC,CAAC;IAC7E,CAAC;IACD,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IAEb,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,WAAW;IACzB,OAAO,CAAC,GAAG,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;QACrD,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC;YACX,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAChB,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED,SAAS,UAAU,CAAI,MAAe;IACpC,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC7B,IAAI,IAAI,EAAE,CAAC;QACT,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;IAC7C,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACxB,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,OAAO,CAAI,MAAe;IACxC,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC/B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,oBAAoB,CAAC,CAAC;IACvD,CAAC;IACD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;QACnB,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACtB,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED,SAAS,aAAa,CAAI,IAAmB;IAC3C,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,MAAwB,CAAC,CAAC;QAEzD,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,qCAAqC;YACrC,SAAS;QACX,CAAC;QAED,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,wBAAwB,CAAC,OAAO,CAAC,CAAC;YAClC,SAAS;QACX,CAAC;QAED,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;QACnC,MAAM,OAAO,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;QAEtC,IAAI,OAAO,CAAC,WAAW,KAAK,IAAI,EAAE,CAAC;YACjC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC;YACzC,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC;YAClD,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;YAC1D,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;YAChE,OAAO,CAAC,UAAU,GAAG;gBACnB,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE;gBACnC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE;aACvC,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,UAAU,GAAG,CAAC,EAAE,KAAK,EAAE,GAAG,MAAM,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;QACvE,CAAC;QAED,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,oBAAoB,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,wBAAwB,CAAI,OAA2B;IAC9D,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IACnC,MAAM,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACnC,OAAO,CAAC,QAAQ,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAEnD,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,QAAuB,CAAC,EAAE,CAAC;QACpD,OAAO,CAAC,UAAU,GAAG,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QACxE,OAAO;IACT,CAAC;IAED,MAAM,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,QAA0B,CAAC,CAAC;IAE/E,IAAI,OAAO,CAAC,WAAW,KAAK,IAAI,IAAI,OAAO,CAAC,WAAW,KAAK,IAAI,EAAE,CAAC;QACjE,OAAO,CAAC,UAAU,GAAG,gBAAgB,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC;QACnE,OAAO,CAAC,OAAO,GAAG,gBAAgB,CAAC,OAAO,CAAC;QAC3C,OAAO;IACT,CAAC;IAED,OAAO,CAAC,UAAU,GAAG,gBAAgB,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC;QAC5E,KAAK,EAAE,OAAO;QACd,OAAO,EAAE,KAAK;KACf,CAAC,CAAC,CAAC;AACN,CAAC;AAED,SAAS,oBAAoB,CAAI,MAAe;IAC9C,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAChC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,EAAE;QAC9D,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,GAAkB,CAAC,CAAC;QACtD,IAAI,SAAS,EAAE,CAAC;YACd,MAAM,SAAS,GAAG,SAAS,EAAE,CAAC;YAC9B,MAAM,OAAO,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;YACtC,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC;YAChD,MAAM,OAAO,GAAoB;gBAC/B,MAAM,EAAE,SAAS;gBACjB,WAAW,EAAE,IAAI;gBACjB,UAAU,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC;aAClD,CAAC;YACF,SAAS,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;QAC9B,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,EAAE,EAAE,CAAC,CAAC;AACT,CAAC;AAED,SAAS,sBAAsB,CAAI,OAA2B;IAC5D,IAAI,OAAO,OAAO,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QAC3C,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;QACnC,MAAM,OAAO,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;QACtC,MAAM,MAAM,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC1C,OAAO,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,OAAO,CAAC,QAAQ,CAAC;AAC1B,CAAC;AAED,SAAS,iBAAiB,CAAI,IAAmB;IAC/C,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;SACxB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAC/B,MAAM,CACL,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;QACX,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;QACf,OAAO,GAAG,CAAC;IACb,CAAC,EACD,EAAuB,CACxB,CAAC;AACN,CAAC;AAED,SAAS,QAAQ,CAAI,IAAmB;IACtC,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,CAAC;IACtE,OAAO,EAAc,CAAC;AACxB,CAAC;AAED,SAAS,UAAU,CAAI,MAAqB,EAAE,MAAqB;IACjE,MAAM,YAAY,GAAG,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;IAC1C,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,QAAQ,EAAE,CAAC;QACb,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;QAClC,IAAI,QAAQ,EAAE,CAAC;YACb,OAAO,YAAY,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IACD,MAAM,CAAC,MAAM,GAAG,EAAE,GAAG,YAAY,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;IACtD,MAAM,CAAC,SAAS,GAAG,EAAE,GAAG,MAAM,CAAC,SAAS,EAAE,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;AAClE,CAAC;AAED,SAAS,SAAS,CAAI,MAAe,EAAE,GAAW;IAChD,OAAO,OAAO,CAAC,WAAW,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;AACnE,CAAC;AAED,SAAS,eAAe,CAAI,MAAe,EAAE,GAAW;IACtD,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5C,MAAM,WAAW,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACpD,IAAI,CAAC,WAAW,EAAE,CAAC;QACjB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC;QAC/C,MAAM,SAAS,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,GAAG,+CAA+C,YAAY,EAAE,IAAI,GAAG,CAAC,CAAC;IAC9G,CAAC;IACD,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,IAAa;IAC7C,OAAO,CACL,OAAO,IAAI,KAAK,UAAU;QAC1B,IAAI,KAAK,OAAO;QAChB,IAAI,KAAK,MAAM;QACf,IAAI,KAAK,MAAM;QACf,IAAI,KAAK,MAAM;QACf,IAAI,KAAK,IAAI;QACb,IAAI,KAAK,MAAM,CAChB,CAAC;AACJ,CAAC","sourcesContent":["import 'reflect-metadata';\nimport type {\n  EntityMeta,\n  EntityOptions,\n  FieldKey,\n  FieldOptions,\n  IdKey,\n  Key,\n  RelationKey,\n  RelationKeyMap,\n  RelationOptions,\n  Type,\n} from '../../type/index.js';\nimport { getKeys, hasKeys, lowerFirst, upperFirst } from '../../util/index.js';\n\nconst holder = globalThis;\nconst metaKey = '@uql/core/entity/decorator';\nconst metas: Map<Type<unknown>, EntityMeta<any>> = holder[metaKey] ?? new Map();\nholder[metaKey] = metas;\n\nexport function defineField<E>(entity: Type<E>, key: string, opts: FieldOptions = {}): EntityMeta<E> {\n  const meta = ensureMeta(entity);\n  if (!opts.type) {\n    const type = inferType(entity, key);\n    opts = { ...opts, type };\n  }\n  meta.fields[key] = { ...meta.fields[key], ...{ name: key, ...opts } };\n  return meta;\n}\n\nexport function defineId<E>(entity: Type<E>, key: string, opts: FieldOptions): EntityMeta<E> {\n  const meta = ensureMeta(entity);\n  const id = getIdKey(meta);\n  if (id) {\n    console.info(`Overriding ID property for '${entity.name}' from '${id}' to '${key}'`);\n    delete meta.fields[id];\n  }\n  return defineField(entity, key, { ...opts, isId: true });\n}\n\nexport function defineRelation<E>(entity: Type<E>, key: string, opts: RelationOptions<E>): EntityMeta<E> {\n  if (!opts.entity) {\n    const inferredType = inferEntityType(entity, key);\n    opts.entity = () => inferredType;\n  }\n  const meta = ensureMeta(entity);\n  meta.relations[key] = { ...meta.relations[key], ...opts };\n  return meta;\n}\n\nexport function defineEntity<E>(entity: Type<E>, opts: EntityOptions = {}): EntityMeta<E> {\n  const meta = ensureMeta(entity);\n\n  if (!hasKeys(meta.fields)) {\n    throw TypeError(`'${entity.name}' must have fields`);\n  }\n\n  const onDeleteKeys = getKeys(meta.fields).filter((key) => meta.fields[key].onDelete) as FieldKey<E>[];\n\n  if (onDeleteKeys.length > 1) {\n    throw TypeError(`'${entity.name}' must have one field with 'onDelete' as maximum`);\n  }\n\n  if (opts.softDelete) {\n    if (!onDeleteKeys.length) {\n      throw TypeError(`'${entity.name}' must have one field with 'onDelete' to enable 'softDelete'`);\n    }\n    meta.softDelete = onDeleteKeys[0];\n  }\n\n  meta.name = opts.name ?? entity.name;\n  let proto: FunctionConstructor = Object.getPrototypeOf(entity.prototype);\n\n  while (proto.constructor !== Object) {\n    const parentMeta = ensureMeta(proto.constructor as Type<E>);\n    extendMeta(meta, parentMeta);\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  const id = getIdKey(meta);\n  if (!id) {\n    throw TypeError(`'${entity.name}' must have one field decorated with @Id`);\n  }\n  meta.id = id;\n\n  return meta;\n}\n\nexport function getEntities(): Type<unknown>[] {\n  return [...metas.entries()].reduce((acc, [key, val]) => {\n    if (val.id) {\n      acc.push(key);\n    }\n    return acc;\n  }, []);\n}\n\nfunction ensureMeta<E>(entity: Type<E>): EntityMeta<E> {\n  let meta = metas.get(entity);\n  if (meta) {\n    return meta;\n  }\n  meta = { entity, fields: {}, relations: {} };\n  metas.set(entity, meta);\n  return meta;\n}\n\nexport function getMeta<E>(entity: Type<E>): EntityMeta<E> {\n  const meta = metas.get(entity);\n  if (!meta) {\n    throw TypeError(`'${entity.name}' is not an entity`);\n  }\n  if (meta.processed) {\n    return meta;\n  }\n  meta.processed = true;\n  return fillRelations(meta);\n}\n\nfunction fillRelations<E>(meta: EntityMeta<E>): EntityMeta<E> {\n  for (const relKey in meta.relations) {\n    const relOpts = meta.relations[relKey as RelationKey<E>];\n\n    if (relOpts.references) {\n      // references were manually specified\n      continue;\n    }\n\n    if (relOpts.mappedBy) {\n      fillInverseSideRelations(relOpts);\n      continue;\n    }\n\n    const relEntity = relOpts.entity();\n    const relMeta = ensureMeta(relEntity);\n\n    if (relOpts.cardinality === 'mm') {\n      const idName = meta.fields[meta.id].name;\n      const relIdName = relMeta.fields[relMeta.id].name;\n      const source = lowerFirst(meta.name) + upperFirst(idName);\n      const target = lowerFirst(relMeta.name) + upperFirst(relIdName);\n      relOpts.references = [\n        { local: source, foreign: meta.id },\n        { local: target, foreign: relMeta.id },\n      ];\n    } else {\n      relOpts.references = [{ local: `${relKey}Id`, foreign: relMeta.id }];\n    }\n\n    if (relOpts.through) {\n      fillThroughRelations(relOpts.through());\n    }\n  }\n\n  return meta;\n}\n\nfunction fillInverseSideRelations<E>(relOpts: RelationOptions<E>): void {\n  const relEntity = relOpts.entity();\n  const relMeta = getMeta(relEntity);\n  relOpts.mappedBy = getMappedByRelationKey(relOpts);\n\n  if (relMeta.fields[relOpts.mappedBy as FieldKey<E>]) {\n    relOpts.references = [{ local: relMeta.id, foreign: relOpts.mappedBy }];\n    return;\n  }\n\n  const mappedByRelation = relMeta.relations[relOpts.mappedBy as RelationKey<E>];\n\n  if (relOpts.cardinality === 'm1' || relOpts.cardinality === 'mm') {\n    relOpts.references = mappedByRelation.references.slice().reverse();\n    relOpts.through = mappedByRelation.through;\n    return;\n  }\n\n  relOpts.references = mappedByRelation.references.map(({ local, foreign }) => ({\n    local: foreign,\n    foreign: local,\n  }));\n}\n\nfunction fillThroughRelations<E>(entity: Type<E>): void {\n  const meta = ensureMeta(entity);\n  meta.relations = getKeys(meta.fields).reduce((relations, key) => {\n    const { reference } = meta.fields[key as FieldKey<E>];\n    if (reference) {\n      const relEntity = reference();\n      const relMeta = ensureMeta(relEntity);\n      const relKey = key.slice(0, -relMeta.id.length);\n      const relOpts: RelationOptions = {\n        entity: reference,\n        cardinality: 'm1',\n        references: [{ local: key, foreign: relMeta.id }],\n      };\n      relations[relKey] = relOpts;\n    }\n    return relations;\n  }, {});\n}\n\nfunction getMappedByRelationKey<E>(relOpts: RelationOptions<E>): Key<E> {\n  if (typeof relOpts.mappedBy === 'function') {\n    const relEntity = relOpts.entity();\n    const relMeta = ensureMeta(relEntity);\n    const keyMap = getRelationKeyMap(relMeta);\n    return relOpts.mappedBy(keyMap);\n  }\n  return relOpts.mappedBy;\n}\n\nfunction getRelationKeyMap<E>(meta: EntityMeta<E>): RelationKeyMap<E> {\n  return getKeys(meta.fields)\n    .concat(getKeys(meta.relations))\n    .reduce(\n      (acc, key) => {\n        acc[key] = key;\n        return acc;\n      },\n      {} as RelationKeyMap<E>,\n    );\n}\n\nfunction getIdKey<E>(meta: EntityMeta<E>): IdKey<E> {\n  const id = getKeys(meta.fields).find((key) => meta.fields[key]?.isId);\n  return id as IdKey<E>;\n}\n\nfunction extendMeta<E>(target: EntityMeta<E>, source: EntityMeta<E>): void {\n  const sourceFields = { ...source.fields };\n  const targetId = getIdKey(target);\n  if (targetId) {\n    const sourceId = getIdKey(source);\n    if (sourceId) {\n      delete sourceFields[sourceId];\n    }\n  }\n  target.fields = { ...sourceFields, ...target.fields };\n  target.relations = { ...source.relations, ...target.relations };\n}\n\nfunction inferType<E>(entity: Type<E>, key: string): any {\n  return Reflect.getMetadata('design:type', entity.prototype, key);\n}\n\nfunction inferEntityType<E>(entity: Type<E>, key: string): Type<any> {\n  const inferredType = inferType(entity, key);\n  const isValidType = isValidEntityType(inferredType);\n  if (!isValidType) {\n    console.log('****', entity, key, inferredType);\n    throw TypeError(`'${entity.name}.${key}' type was auto-inferred with invalid type '${inferredType?.name}'`);\n  }\n  return inferredType;\n}\n\nexport function isValidEntityType(type: unknown): type is Type<unknown> {\n  return (\n    typeof type === 'function' &&\n    type !== Boolean &&\n    type !== String &&\n    type !== Number &&\n    type !== BigInt &&\n    type !== Date &&\n    type !== Symbol\n  );\n}\n"]}

package/{entity → dist/entity}/decorator/entity.d.ts

@@ -1,2 +1,2 @@
-import { EntityOptions, Type } from '../../type';
+import type { EntityOptions, Type } from '../../type/index.js';
 export declare function Entity<E>(opts?: EntityOptions): (entity: Type<E>) => void;

package/dist/entity/decorator/entity.js

@@ -0,0 +1,7 @@
+import { defineEntity } from './definition.js';
+export function Entity(opts) {
+    return (entity) => {
+        defineEntity(entity, opts);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2VudGl0eS9kZWNvcmF0b3IvZW50aXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxNQUFNLFVBQVUsTUFBTSxDQUFJLElBQW9CO0lBQzVDLE9BQU8sQ0FBQyxNQUFlLEVBQVEsRUFBRTtRQUMvQixZQUFZLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQzdCLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEVudGl0eU9wdGlvbnMsIFR5cGUgfSBmcm9tICcuLi8uLi90eXBlL2luZGV4LmpzJztcbmltcG9ydCB7IGRlZmluZUVudGl0eSB9IGZyb20gJy4vZGVmaW5pdGlvbi5qcyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBFbnRpdHk8RT4ob3B0cz86IEVudGl0eU9wdGlvbnMpIHtcbiAgcmV0dXJuIChlbnRpdHk6IFR5cGU8RT4pOiB2b2lkID0+IHtcbiAgICBkZWZpbmVFbnRpdHkoZW50aXR5LCBvcHRzKTtcbiAgfTtcbn1cbiJdfQ==

package/{entity → dist/entity}/decorator/field.d.ts

@@ -1,2 +1,2 @@
-import { FieldOptions } from '../../type';
+import type { FieldOptions } from '../../type/index.js';
 export declare function Field<E>(opts?: FieldOptions): (target: object, key: string) => void;

package/dist/entity/decorator/field.js

@@ -0,0 +1,8 @@
+import { defineField } from './definition.js';
+export function Field(opts) {
+    return (target, key) => {
+        const entity = target.constructor;
+        defineField(entity, key, opts);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZW50aXR5L2RlY29yYXRvci9maWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFOUMsTUFBTSxVQUFVLEtBQUssQ0FBSSxJQUFtQjtJQUMxQyxPQUFPLENBQUMsTUFBYyxFQUFFLEdBQVcsRUFBUSxFQUFFO1FBQzNDLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxXQUFzQixDQUFDO1FBQzdDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQ2pDLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEZpZWxkT3B0aW9ucywgVHlwZSB9IGZyb20gJy4uLy4uL3R5cGUvaW5kZXguanMnO1xuaW1wb3J0IHsgZGVmaW5lRmllbGQgfSBmcm9tICcuL2RlZmluaXRpb24uanMnO1xuXG5leHBvcnQgZnVuY3Rpb24gRmllbGQ8RT4ob3B0cz86IEZpZWxkT3B0aW9ucykge1xuICByZXR1cm4gKHRhcmdldDogb2JqZWN0LCBrZXk6IHN0cmluZyk6IHZvaWQgPT4ge1xuICAgIGNvbnN0IGVudGl0eSA9IHRhcmdldC5jb25zdHJ1Y3RvciBhcyBUeXBlPEU+O1xuICAgIGRlZmluZUZpZWxkKGVudGl0eSwga2V5LCBvcHRzKTtcbiAgfTtcbn1cbiJdfQ==

package/{entity → dist/entity}/decorator/id.d.ts

@@ -1,2 +1,2 @@
-import { FieldOptions } from '../../type';
+import type { FieldOptions } from '../../type/index.js';
 export declare function Id<E>(opts?: Omit<FieldOptions, 'isId'>): (target: object, key: string) => void;

package/dist/entity/decorator/id.js

@@ -0,0 +1,8 @@
+import { defineId } from './definition.js';
+export function Id(opts) {
+    return (target, key) => {
+        const entity = target.constructor;
+        defineId(entity, key, opts);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZW50aXR5L2RlY29yYXRvci9pZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFM0MsTUFBTSxVQUFVLEVBQUUsQ0FBSSxJQUFpQztJQUNyRCxPQUFPLENBQUMsTUFBYyxFQUFFLEdBQVcsRUFBUSxFQUFFO1FBQzNDLE1BQU0sTUFBTSxHQUFHLE1BQU0sQ0FBQyxXQUFzQixDQUFDO1FBQzdDLFFBQVEsQ0FBQyxNQUFNLEVBQUUsR0FBRyxFQUFFLElBQUksQ0FBQyxDQUFDO0lBQzlCLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEZpZWxkT3B0aW9ucywgVHlwZSB9IGZyb20gJy4uLy4uL3R5cGUvaW5kZXguanMnO1xuaW1wb3J0IHsgZGVmaW5lSWQgfSBmcm9tICcuL2RlZmluaXRpb24uanMnO1xuXG5leHBvcnQgZnVuY3Rpb24gSWQ8RT4ob3B0cz86IE9taXQ8RmllbGRPcHRpb25zLCAnaXNJZCc+KSB7XG4gIHJldHVybiAodGFyZ2V0OiBvYmplY3QsIGtleTogc3RyaW5nKTogdm9pZCA9PiB7XG4gICAgY29uc3QgZW50aXR5ID0gdGFyZ2V0LmNvbnN0cnVjdG9yIGFzIFR5cGU8RT47XG4gICAgZGVmaW5lSWQoZW50aXR5LCBrZXksIG9wdHMpO1xuICB9O1xufVxuIl19

package/dist/entity/decorator/index.d.ts

@@ -0,0 +1,5 @@
+export { getEntities, getMeta } from './definition.js';
+export * from './entity.js';
+export * from './field.js';
+export * from './id.js';
+export * from './relation.js';

package/dist/entity/decorator/index.js

@@ -0,0 +1,6 @@
+export { getEntities, getMeta } from './definition.js';
+export * from './entity.js';
+export * from './field.js';
+export * from './id.js';
+export * from './relation.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZW50aXR5L2RlY29yYXRvci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZELGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZ2V0RW50aXRpZXMsIGdldE1ldGEgfSBmcm9tICcuL2RlZmluaXRpb24uanMnO1xuZXhwb3J0ICogZnJvbSAnLi9lbnRpdHkuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9maWVsZC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2lkLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcmVsYXRpb24uanMnO1xuIl19

package/{entity → dist/entity}/decorator/relation.d.ts

@@ -1,4 +1,4 @@
-import { RelationOptions, RelationOneToOneOptions, RelationOneToManyOptions, RelationManyToOneOptions, RelationManyToManyOptions } from '../../type';
+import type { RelationManyToManyOptions, RelationManyToOneOptions, RelationOneToManyOptions, RelationOneToOneOptions, RelationOptions } from '../../type/index.js';
 declare function Relation<E>(opts: RelationOptions<E>): (target: object, key: string) => void;
 type RelationReturn = ReturnType<typeof Relation>;
 export declare function OneToOne<E>(opts?: RelationOneToOneOptions<E>): RelationReturn;

package/dist/entity/decorator/relation.js

@@ -0,0 +1,20 @@
+import { defineRelation } from './definition.js';
+function Relation(opts) {
+    return (target, key) => {
+        const entity = target.constructor;
+        defineRelation(entity, key, opts);
+    };
+}
+export function OneToOne(opts) {
+    return Relation({ cardinality: '11', ...opts });
+}
+export function ManyToOne(opts) {
+    return Relation({ cardinality: 'm1', ...opts });
+}
+export function OneToMany(opts) {
+    return Relation({ cardinality: '1m', ...opts });
+}
+export function ManyToMany(opts) {
+    return Relation({ cardinality: 'mm', ...opts });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/entity/index.d.ts

@@ -0,0 +1 @@
+export * from './decorator/index.js';

package/dist/entity/index.js

@@ -0,0 +1,2 @@
+export * from './decorator/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZW50aXR5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RlY29yYXRvci9pbmRleC5qcyc7XG4iXX0=

package/dist/express/index.d.ts

@@ -0,0 +1,2 @@
+export * from './querierMiddleware.js';
+export * from './query.util.js';

package/dist/express/index.js

@@ -0,0 +1,3 @@
+export * from './querierMiddleware.js';
+export * from './query.util.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZXhwcmVzcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3F1ZXJpZXJNaWRkbGV3YXJlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnkudXRpbC5qcyc7XG4iXX0=

package/dist/express/querierMiddleware.d.ts

@@ -0,0 +1,26 @@
+import { type Request, type Router } from 'express';
+import type { EntityMeta, Type } from '../type/index.js';
+export declare function querierMiddleware(opts?: MiddlewareOptions): Router;
+export declare function buildQuerierRouter<E>(entity: Type<E>, opts: ExtraOptions): Router;
+type ExtraOptions = {
+    /**
+     * Allow augment any kind of request before it runs
+     */
+    readonly pre?: Pre;
+    /**
+     * Allow augment a saving request (POST, PATCH, PUT) before it runs
+     */
+    readonly preSave?: PreSave;
+    /**
+     * Allow augment a filtering request (GET, PUT, DELETE) before it runs
+     */
+    readonly preFilter?: PreFilter;
+};
+type MiddlewareOptions = {
+    readonly include?: Type<unknown>[];
+    readonly exclude?: Type<unknown>[];
+} & ExtraOptions;
+type Pre = <E = unknown>(req: Request, meta: EntityMeta<E>) => void;
+type PreSave = <E = unknown>(req: Request, meta: EntityMeta<E>) => void;
+type PreFilter = <E = unknown>(req: Request, meta: EntityMeta<E>) => void;
+export {};