pangea-server 1.0.1

package/dist/database/db.class.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Db = void 0;
+const sequelize_1 = require("sequelize");
+const db_client_1 = require("./db-client");
+const _1 = require(".");
+// helpers
+const helpers_1 = require("../helpers");
+const pangea_helpers_1 = require("pangea-helpers");
+class Db {
+    constructor(tx) {
+        this.__tx = tx;
+    }
+    // find methods
+    findOneOrNull(model, filters, options = {}) {
+        const { scopes = [], attributes, include = [], order, paranoid = true } = options;
+        const scopedModel = scopes.length ? model.scope(...scopes) : model;
+        const baseOptions = { attributes: getFinalAttributes(attributes), paranoid, transaction: this.__tx };
+        if (typeof filters === 'number') {
+            return scopedModel.findByPk(filters, { ...getIncludeAndWhere(model, include), ...baseOptions });
+        }
+        return scopedModel.findOne({
+            ...getIncludeAndWhere(model, include, filters),
+            order: getFinalOrder(order),
+            ...baseOptions,
+        });
+    }
+    async findOne(model, filters, options = {}) {
+        const instance = await this.findOneOrNull(model, filters, options);
+        if (!instance)
+            helpers_1.AppError.ThrowEntityNotFound();
+        return instance;
+    }
+    async findMany(model, options = {}) {
+        const { attributes, include = [], where, searchFields, search, group, order, page, pageSize, paranoid = 'active', } = options;
+        let searchWhere;
+        if (searchFields?.length && search) {
+            const searchWords = search.split(/\s+/).filter(Boolean);
+            searchWhere = {
+                [_1.Ops.and]: searchWords.map((word) => ({
+                    [_1.Ops.or]: searchFields.map((field) => {
+                        const finalField = field.includes('.') ? `$${field}$` : field;
+                        return { [finalField]: { [_1.Ops.like]: `%${word}%` } };
+                    }),
+                })),
+            };
+        }
+        const deletedAtWhere = paranoid === 'deleted' ? { deletedAt: { [_1.Ops.not]: null } } : {};
+        const baseOptions = {
+            attributes: getFinalAttributes(attributes),
+            ...getIncludeAndWhere(model, include, {
+                ...where,
+                ...searchWhere,
+                ...deletedAtWhere,
+            }),
+            ...(group && { group }),
+            order: [...getFinalOrder(order), ['createdAt', 'DESC']],
+            paranoid: paranoid === 'active',
+            subQuery: false,
+            transaction: this.__tx,
+        };
+        if (page && pageSize) {
+            const [instances, totalCount] = await Promise.all([
+                (async () => {
+                    const idRows = await model.findAll({
+                        ...baseOptions,
+                        attributes: [[(0, sequelize_1.col)(`${model.name}.id`), 'id']],
+                        group: [`${model.name}.id`],
+                        raw: true,
+                        offset: (page - 1) * pageSize,
+                        limit: pageSize,
+                    });
+                    const ids = idRows.map((row) => row.id);
+                    return model.findAll({
+                        ...baseOptions,
+                        where: { id: { [_1.Ops.in]: ids } },
+                    });
+                })(),
+                model.count({ ...baseOptions, col: 'id', distinct: true }),
+            ]);
+            return { instances, totalCount };
+        }
+        const instances = await model.findAll(baseOptions);
+        return { instances, totalCount: instances.length };
+    }
+    // insert methods
+    insertOne(model, params) {
+        return handleDbError(async () => {
+            const newInstance = await model.create(params, { transaction: this.__tx });
+            return this.findOne(model, newInstance.id);
+        });
+    }
+    insertMany(model, data, options = {}) {
+        return handleDbError(async () => {
+            const newInstances = await model.bulkCreate(data, {
+                ...options,
+                validate: true,
+                transaction: this.__tx,
+            });
+            return newInstances.length;
+        });
+    }
+    // update methods
+    updateOne(model, target, params) {
+        return handleDbError(async () => {
+            const instance = await this.__getInstance(model, target);
+            await instance.update(params, { transaction: this.__tx });
+            return this.findOne(model, instance.id);
+        });
+    }
+    updateMany(model, where, params) {
+        return handleDbError(async () => {
+            const [count] = await model.update(params, { where, transaction: this.__tx });
+            return count;
+        });
+    }
+    // delete methods
+    deleteOne(model, target) {
+        return this.__deleteOne(model, target, false);
+    }
+    deleteMany(model, where) {
+        return this.__deleteMany(model, where, false);
+    }
+    // destroy methods
+    destroyOne(model, target) {
+        return this.__deleteOne(model, target, true);
+    }
+    destroyMany(model, where) {
+        return this.__deleteMany(model, where, true);
+    }
+    // restore methods
+    restoreOne(model, target) {
+        return handleDbError(async () => {
+            const instance = await this.__getInstance(model, target, false);
+            await instance.restore({ transaction: this.__tx });
+            return this.findOne(model, instance.id);
+        });
+    }
+    restoreMany(model, where) {
+        return handleDbError(() => {
+            return model.restore({ where, transaction: this.__tx });
+        });
+    }
+    // helpers methods
+    __getInstance(model, target, paranoid = true) {
+        if (target && typeof target === 'object' && 'id' in target)
+            return target;
+        return this.findOne(model, target, { paranoid });
+    }
+    __deleteOne(model, target, force) {
+        return handleDbError(async () => {
+            const instance = await this.__getInstance(model, target);
+            await instance.destroy({ force, transaction: this.__tx });
+            return this.findOneOrNull(model, instance.id, { paranoid: false });
+        });
+    }
+    __deleteMany(model, where, force) {
+        return handleDbError(() => {
+            return model.destroy({ where, force, transaction: this.__tx });
+        });
+    }
+    // foreign key methods
+    enableForeignKeyChecks() {
+        const dbClient = (0, db_client_1.getDbClient)();
+        return dbClient.query('SET FOREIGN_KEY_CHECKS = 1', { transaction: this.__tx });
+    }
+    disableForeignKeyChecks() {
+        const dbClient = (0, db_client_1.getDbClient)();
+        return dbClient.query('SET FOREIGN_KEY_CHECKS = 0', { transaction: this.__tx });
+    }
+}
+exports.Db = Db;
+// internal functions
+function getFinalAttributes(attributes) {
+    if (!attributes)
+        return;
+    return attributes.map(([column, alias]) => {
+        if (typeof column === 'string')
+            return [(0, sequelize_1.col)(column), alias];
+        const [op, field] = column;
+        return [(0, sequelize_1.fn)(op, (0, sequelize_1.col)(field)), alias];
+    });
+}
+function convertWhereKeys(obj) {
+    if (Array.isArray(obj)) {
+        return obj.map(convertWhereKeys);
+    }
+    else if (obj &&
+        typeof obj === 'object' &&
+        !(obj instanceof Date) &&
+        !(obj instanceof RegExp) &&
+        !(obj instanceof Map) &&
+        !(obj instanceof Set) &&
+        !(typeof obj === 'function')) {
+        const newObj = {};
+        for (const key of Reflect.ownKeys(obj)) {
+            const value = obj[key];
+            let newKey = key;
+            if (typeof key === 'string' && key.startsWith('$') && key.endsWith('$')) {
+                const inner = key.slice(1, -1);
+                const parts = inner.split('.');
+                if (parts.length >= 2) {
+                    const last = parts.pop();
+                    const transformed = (0, pangea_helpers_1.camelToSnake)(last);
+                    newKey = `$${[...parts, transformed].join('.')}$`;
+                }
+            }
+            newObj[newKey] = convertWhereKeys(value);
+        }
+        return newObj;
+    }
+    return obj;
+}
+function getIncludeAndWhere(model, includeItems, where, relDepth = new Map()) {
+    const includeOptions = [];
+    const cleanWhere = { ...where };
+    for (const [relName, rel] of Object.entries(model.Relations)) {
+        const relKey = `${model.name}.${relName}`;
+        const currentDepth = relDepth.get(relKey) || 0;
+        const maxDepth = rel.joinDepth;
+        if (currentDepth >= maxDepth)
+            continue;
+        const { active = true, include: nestedIncludeItems = [] } = includeItems.find((i) => i.relation === relName) || {};
+        if (!rel.eager || !active)
+            continue;
+        const relWhere = cleanWhere[relName];
+        delete cleanWhere[relName];
+        const newRelDepth = new Map(relDepth);
+        newRelDepth.set(relKey, currentDepth + 1);
+        const relModel = rel.getModelFn();
+        includeOptions.push({
+            model: relModel,
+            as: relName,
+            required: rel.required,
+            paranoid: rel.paranoid,
+            ...getIncludeAndWhere(relModel, nestedIncludeItems, relWhere, newRelDepth),
+        });
+    }
+    return {
+        include: includeOptions,
+        ...(Reflect.ownKeys(cleanWhere).length && { where: convertWhereKeys(cleanWhere) }),
+    };
+}
+function getFinalOrder(order) {
+    return Object.entries(order || {}).map(([key, value]) => {
+        const parts = key.split('.');
+        const direction = value.toUpperCase();
+        return [...parts, direction];
+    });
+}
+async function handleDbError(operation) {
+    try {
+        return await operation();
+    }
+    catch (err) {
+        if (err instanceof sequelize_1.UniqueConstraintError) {
+            helpers_1.AppError.Throw({ statusCodeName: 'BAD_REQUEST', errorCode: 'DUPLICATE_KEY', err });
+        }
+        if (err instanceof sequelize_1.ForeignKeyConstraintError) {
+            const originalErr = err.original;
+            if (originalErr.errno === 1451) {
+                helpers_1.AppError.Throw({ statusCodeName: 'CONFLICT', errorCode: 'MODELS_ASSOCIATED', err });
+            }
+            if (originalErr.errno === 1452) {
+                helpers_1.AppError.Throw({ statusCodeName: 'BAD_REQUEST', errorCode: 'FOREIGN_KEY_INTEGRITY', err });
+            }
+        }
+        throw err;
+    }
+}

package/dist/database/decorators/columns/column.d.ts

@@ -0,0 +1,10 @@
+import type { ModelValidateOptions } from 'sequelize';
+import type { ColumnType, ColGeneralOptions, ColVirtualOptions } from '../../../database/database.types';
+type ForeignKeyAction = 'RESTRICT' | 'CASCADE' | 'SET NULL';
+type ColumnOptions = ColGeneralOptions & ColVirtualOptions & {
+    validate?: ModelValidateOptions;
+    onUpdate?: ForeignKeyAction;
+    onDelete?: ForeignKeyAction;
+};
+export declare function Column(type: ColumnType, options?: ColumnOptions): (target: any, propertyName: string) => void;
+export {};

package/dist/database/decorators/columns/column.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Column = void 0;
+const seq = __importStar(require("sequelize-typescript"));
+function Column(type, options = {}) {
+    const { nullable = false, defaultValue, index, unique = false, exclude, get, set, ...restOptions } = options;
+    return function (target, propertyName) {
+        seq.Column({
+            type: typeof type === 'string' ? seq.DataType[type] : type,
+            allowNull: nullable,
+            defaultValue,
+            ...(get && { get }),
+            ...(set && { set }),
+            ...restOptions,
+        })(target, propertyName);
+        const model = target.constructor;
+        model.AddColumn(propertyName, { allowNull: nullable, defaultValue });
+        if (index || unique)
+            model.AddColumnIndex({ field: propertyName, unique });
+        if (exclude)
+            model.AddExcludedAttribute(propertyName);
+    };
+}
+exports.Column = Column;

package/dist/database/decorators/columns/date.columns.d.ts

@@ -0,0 +1,4 @@
+import type { ColGeneralOptions } from '../../../database/database.types';
+export declare function ColDatetime(options?: ColGeneralOptions): (target: any, propertyName: string) => void;
+export declare function ColDate(options?: ColGeneralOptions): (target: any, propertyName: string) => void;
+export declare function ColTime(options?: ColGeneralOptions): (target: any, propertyName: string) => void;

package/dist/database/decorators/columns/date.columns.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColTime = exports.ColDate = exports.ColDatetime = void 0;
+const column_1 = require("./column");
+function ColDatetime(options) {
+    return (0, column_1.Column)('DATE', options);
+}
+exports.ColDatetime = ColDatetime;
+function ColDate(options) {
+    return (0, column_1.Column)('DATEONLY', options);
+}
+exports.ColDate = ColDate;
+function ColTime(options) {
+    return (0, column_1.Column)('TIME', options);
+}
+exports.ColTime = ColTime;

package/dist/database/decorators/columns/general.columns.d.ts

@@ -0,0 +1,4 @@
+import type { ColGeneralOptions, ColVirtualGet, ColVirtualOptions, GetModelFn } from '../../../database/database.types';
+export declare function ColBool(options?: ColGeneralOptions): (target: any, propertyName: string) => void;
+export declare function ColForeignKey(getModelFn: GetModelFn, options?: ColGeneralOptions): (target: any, propertyName: string) => void;
+export declare function ColVirtual(options?: ColVirtualOptions | ColVirtualGet): Function;

package/dist/database/decorators/columns/general.columns.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColVirtual = exports.ColForeignKey = exports.ColBool = void 0;
+const seq = __importStar(require("sequelize-typescript"));
+const column_1 = require("./column");
+function ColBool(options) {
+    return (0, column_1.Column)('BOOLEAN', options);
+}
+exports.ColBool = ColBool;
+function ColForeignKey(getModelFn, options) {
+    return function (target, propertyName) {
+        (0, column_1.Column)('INTEGER', { ...options, onUpdate: 'RESTRICT', onDelete: 'RESTRICT' })(target, propertyName);
+        seq.ForeignKey(getModelFn)(target, propertyName);
+    };
+}
+exports.ColForeignKey = ColForeignKey;
+function ColVirtual(options) {
+    let get;
+    let set;
+    if (options) {
+        if (typeof options === 'function') {
+            get = options;
+        }
+        else {
+            get = options.get;
+            set = options.set;
+        }
+    }
+    return seq.Column({ type: seq.DataType.VIRTUAL, ...(get && { get }), ...(set && { set }) });
+}
+exports.ColVirtual = ColVirtual;

package/dist/database/decorators/columns/json.columns.d.ts

@@ -0,0 +1,3 @@
+import type { ColGeneralOptions } from '../../../database/database.types';
+export declare function ColJson(options?: ColGeneralOptions): (target: any, propertyName: string) => void;
+export declare function ColStrArray(): (target: any, propertyName: string) => void;

package/dist/database/decorators/columns/json.columns.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColStrArray = exports.ColJson = void 0;
+const column_1 = require("./column");
+function ColJson(options) {
+    return (0, column_1.Column)('JSON', options);
+}
+exports.ColJson = ColJson;
+function ColStrArray() {
+    return function (target, propertyName) {
+        (0, column_1.Column)('TEXT', {
+            get() {
+                const val = this.getDataValue(propertyName);
+                return typeof val === 'string' && val.length > 0 ? val.split(',') : [];
+            },
+            set(val) {
+                this.setDataValue(propertyName, val.join(','));
+            },
+        })(target, propertyName);
+    };
+}
+exports.ColStrArray = ColStrArray;

package/dist/database/decorators/columns/number.columns.d.ts

@@ -0,0 +1,10 @@
+import type { ColGeneralOptions } from '../../../database/database.types';
+type ColNumOptions = ColGeneralOptions & {
+    min?: number;
+    max?: number;
+};
+export declare function ColInt(options?: ColNumOptions): (target: any, propertyName: string) => void;
+export declare function ColBigInt(options?: ColNumOptions): (target: any, propertyName: string) => void;
+export declare function ColFloat(options?: ColNumOptions): (target: any, propertyName: string) => void;
+export declare function ColDouble(options?: ColNumOptions): (target: any, propertyName: string) => void;
+export {};

package/dist/database/decorators/columns/number.columns.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColDouble = exports.ColFloat = exports.ColBigInt = exports.ColInt = void 0;
+const column_1 = require("./column");
+function ColInt(options) {
+    return getNumColumn('INTEGER', options);
+}
+exports.ColInt = ColInt;
+function ColBigInt(options) {
+    return getNumColumn('BIGINT', options);
+}
+exports.ColBigInt = ColBigInt;
+function ColFloat(options) {
+    return getNumColumn('FLOAT', options);
+}
+exports.ColFloat = ColFloat;
+function ColDouble(options) {
+    return getNumColumn('DOUBLE', options);
+}
+exports.ColDouble = ColDouble;
+// internal functions
+function getNumColumn(type, options = {}) {
+    const { min, max, ...restOptions } = options;
+    const validate = {};
+    if (min !== undefined)
+        validate.min = min;
+    if (max !== undefined)
+        validate.max = max;
+    return (0, column_1.Column)(type, {
+        ...restOptions,
+        ...(Object.keys(validate).length ? { validate } : {}),
+    });
+}

package/dist/database/decorators/columns/string.columns.d.ts

@@ -0,0 +1,10 @@
+import { type StringLength } from '../../../resources';
+import type { ColGeneralOptions } from '../../../database/database.types';
+type ColStrOptions = ColGeneralOptions & {
+    minLength?: StringLength | number;
+    maxLength: StringLength | number;
+    regex?: RegExp;
+};
+export declare function ColStr(options: ColStrOptions): (target: any, propertyName: string) => void;
+export declare function ColText(options?: Partial<ColStrOptions>): (target: any, propertyName: string) => void;
+export {};

package/dist/database/decorators/columns/string.columns.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColText = exports.ColStr = void 0;
+const seq = __importStar(require("sequelize-typescript"));
+const column_1 = require("./column");
+// resources
+const resources_1 = require("../../../resources");
+function ColStr(options) {
+    return getStrColumn(seq.DataType.STRING(getLength(255, options.maxLength)), options);
+}
+exports.ColStr = ColStr;
+function ColText(options) {
+    return getStrColumn('TEXT', options);
+}
+exports.ColText = ColText;
+// internal functions
+function getStrColumn(type, options = {}) {
+    return (0, column_1.Column)(type, {
+        ...options,
+        validate: {
+            len: [getLength(0, options.minLength), getLength(Infinity, options.maxLength)],
+            ...(options.regex ? { is: options.regex } : {}),
+        },
+    });
+}
+function getLength(fallbackLength, length) {
+    if (!length)
+        return fallbackLength;
+    if (typeof length === 'number')
+        return length;
+    return resources_1.STRING_LENGTHS[length];
+}

package/dist/database/decorators/index.d.ts

@@ -0,0 +1,23 @@
+import * as str from './columns/string.columns';
+import * as num from './columns/number.columns';
+import * as date from './columns/date.columns';
+import * as json from './columns/json.columns';
+import * as general from './columns/general.columns';
+export { Table } from './table';
+export declare const col: {
+    Str: typeof str.ColStr;
+    Text: typeof str.ColText;
+    Int: typeof num.ColInt;
+    BigInt: typeof num.ColBigInt;
+    Float: typeof num.ColFloat;
+    Double: typeof num.ColDouble;
+    Datetime: typeof date.ColDatetime;
+    Date: typeof date.ColDate;
+    Time: typeof date.ColTime;
+    Json: typeof json.ColJson;
+    StrArray: typeof json.ColStrArray;
+    Bool: typeof general.ColBool;
+    ForeignKey: typeof general.ColForeignKey;
+    Virtual: typeof general.ColVirtual;
+};
+export * as rel from './relations';

package/dist/database/decorators/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rel = exports.col = exports.Table = void 0;
+const str = __importStar(require("./columns/string.columns"));
+const num = __importStar(require("./columns/number.columns"));
+const date = __importStar(require("./columns/date.columns"));
+const json = __importStar(require("./columns/json.columns"));
+const general = __importStar(require("./columns/general.columns"));
+var table_1 = require("./table");
+Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return table_1.Table; } });
+exports.col = {
+    Str: str.ColStr,
+    Text: str.ColText,
+    Int: num.ColInt,
+    BigInt: num.ColBigInt,
+    Float: num.ColFloat,
+    Double: num.ColDouble,
+    Datetime: date.ColDatetime,
+    Date: date.ColDate,
+    Time: date.ColTime,
+    Json: json.ColJson,
+    StrArray: json.ColStrArray,
+    Bool: general.ColBool,
+    ForeignKey: general.ColForeignKey,
+    Virtual: general.ColVirtual,
+};
+exports.rel = __importStar(require("./relations"));

package/dist/database/decorators/relations.d.ts

@@ -0,0 +1,12 @@
+import type { GetModelFn } from '../database.types';
+type RelationOptions = {
+    eager?: boolean;
+    required?: boolean;
+    paranoid?: boolean;
+    joinDepth?: number;
+    foreignKey?: string;
+};
+export declare const BelongsTo: (getModelFn: GetModelFn, options?: RelationOptions) => (target: any, propertyName: string) => void;
+export declare const HasOne: (getModelFn: GetModelFn, options?: RelationOptions) => (target: any, propertyName: string) => void;
+export declare const HasMany: (getModelFn: GetModelFn, options?: RelationOptions) => (target: any, propertyName: string) => void;
+export {};