@decaf-ts/core/lib/esm/overrides/overrides.js

Core persistence module for the decaf framework

import { Metadata } from "@decaf-ts/decoration";
import { Model } from "@decaf-ts/decorator-validation";
import { DBKeys, InternalError } from "@decaf-ts/db-decorators";
import { Adapter } from "./../persistence/Adapter.js";
import { PersistenceKeys } from "./../persistence/constants.js";
import { UnsupportedError } from "./../persistence/errors.js";
import { Injectables } from "@decaf-ts/injectable-decorators";
Metadata.validationExceptions = function (model, op) {
    const noValidation = Metadata.get(model, PersistenceKeys.NO_VALIDATE) || [];
    const novalidationEntries = Object.entries(noValidation)
        .filter(([, val]) => val.includes(op))
        .map(([key]) => key);
    const nestedRels = Model.nestedRelations(model);
    return [...new Set([...novalidationEntries, ...nestedRels])];
}.bind(Metadata);
Metadata.migrationsFor = function (adapter) {
    adapter = adapter ?? Adapter.current;
    if (!adapter)
        throw new InternalError(`Could not get adapter for migrations`);
    const migrations = Metadata["innerGet"](Symbol.for(PersistenceKeys.MIGRATION), adapter.alias);
    return migrations.map((m) => m.class);
}.bind(Metadata);
Metadata.relations = function (m, prop) {
    const meta = Metadata.get(m, PersistenceKeys.RELATIONS);
    if (!meta)
        return undefined;
    if (!prop)
        return Object.keys(meta);
    if (!meta[prop])
        throw new InternalError(`No relations metadata found for property ${prop}`);
    return meta[prop];
}.bind(Metadata);
Model.relations = function (m, prop) {
    return (Metadata.relations(m instanceof Model ? m.constructor : m, prop) || []);
};
Model.nestedRelations = function (model, existingRelations) {
    if (!existingRelations?.length)
        existingRelations = Model.relations(model);
    let inner = [];
    const rels = Metadata.get(model, PersistenceKeys.RELATIONS);
    if (!rels || !Object.keys(rels).length)
        return [...new Set([...existingRelations])];
    for (const prop in rels) {
        const relationMeta = rels[prop];
        if (relationMeta?.class && Model.relations(relationMeta.class)) {
            const innerModelRels = Model.relations(relationMeta.class);
            const innerModelDotRels = innerModelRels.map((r) => `${prop}.${r}`);
            existingRelations = [
                ...existingRelations,
                ...innerModelRels,
                ...innerModelDotRels,
            ];
            inner = Model.nestedRelations(relationMeta.class, existingRelations);
        }
    }
    return [...new Set([...existingRelations, ...inner])];
};
Model.generated = function generated(model, prop) {
    return !!Metadata.get(typeof model !== "function" ? model.constructor : model, Metadata.key(PersistenceKeys.GENERATED, prop));
}.bind(Metadata);
Model.generatedBySequence = function generatedBySequence(model, prop) {
    const constr = typeof model !== "function" ? model.constructor : model;
    const seq = Model.sequenceFor(constr);
    return !!seq.generated;
}.bind(Metadata);
Metadata.createdBy = function createdBy(model) {
    const meta = Metadata.get(typeof model !== "function" ? model.constructor : model, PersistenceKeys.CREATED_BY);
    if (!meta)
        throw new InternalError(`No createdBy metadata found for model. did you use @createdBy()?`);
    return meta;
}.bind(Metadata);
Metadata.updatedBy = function updatedBy(model) {
    const meta = Metadata.get(typeof model !== "function" ? model.constructor : model, PersistenceKeys.UPDATED_BY);
    if (!meta)
        throw new InternalError(`No updatedBy metadata found for model. did you use @updatedBy()?`);
    return meta;
}.bind(Metadata);
Model.tableName = function (model) {
    const obj = model instanceof Model ? Model.get(model.constructor.name) : model;
    if (!obj)
        throw new InternalError(`Unable to find model ${model}`);
    const meta = Metadata.get(model instanceof Model ? model.constructor : model, PersistenceKeys.TABLE);
    if (meta) {
        return meta;
    }
    if (model instanceof Model) {
        return model.constructor.name;
    }
    return model.name;
};
Model.columnName = function (model, attribute) {
    const metadata = Metadata.get(model instanceof Model ? model.constructor : model, Metadata.key(PersistenceKeys.COLUMN, attribute));
    return metadata ? metadata : attribute;
};
Model.sequenceName = function (model, ...args) {
    return [Model.tableName(model), ...args].join("_");
};
Model.sequenceFor = function sequenceFor(model, property) {
    if (property)
        throw new UnsupportedError("not currently supported");
    const metadata = Model.pkProps(model instanceof Model ? model.constructor : model);
    if (!metadata)
        throw new InternalError("No sequence options defined for model. did you use the @pk decorator?");
    return metadata;
};
Model.indexes = function indexes(model) {
    const indexDecorators = Metadata.get(model instanceof Model ? model.constructor : model, PersistenceKeys.INDEX);
    return Object.keys(indexDecorators || {}).reduce((acum, t) => {
        acum[t] = { [PersistenceKeys.INDEX]: indexDecorators[t] };
        return acum;
    }, {});
};
Injectables.services = function () {
    return Metadata["innerGet"](Symbol.for(PersistenceKeys.SERVICE));
};
Injectables.repositories = function () {
    return Metadata["innerGet"](Symbol.for(DBKeys.REPOSITORY));
};
//# sourceMappingURL=overrides.js.map