@rws-framework/db 2.4.5 → 3.0.0

package/dist/decorators/IdType.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+import { IIdTypeOpts } from '../models/interfaces/IIdTypeOpts';
+export interface IIdMetaOpts extends IIdTypeOpts {
+    type: any;
+}
+declare function IdType(type: any, opts?: IIdTypeOpts | null, tags?: string[]): (target: any, key: string) => void;
+export default IdType;
+export { IIdTypeOpts };

package/dist/decorators/IdType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+function IdType(type, opts = null, tags = []) {
+    const metaOpts = { type, dbOptions: opts && opts.dbOptions ? opts.dbOptions : null };
+    return function (target, key) {
+        Reflect.defineMetadata(`IdType:${key}`, metaOpts, target);
+    };
+}
+exports.default = IdType;

package/dist/decorators/InverseRelation.d.ts

@@ -1,12 +1,12 @@
 import 'reflect-metadata';
 import { RWSModel, OpModelType } from '../models/_model';
-interface InverseRelationOpts {
+export interface InverseRelationOpts {
     key: string;
     inversionModel: OpModelType<RWSModel<any>>;
     foreignKey: string;
     singular?: boolean;
     relationName?: string;
+    mappingName?: string;
 }
 declare function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions?: Partial<InverseRelationOpts>): (target: any, key: string) => void;
 export default InverseRelation;
-export { InverseRelationOpts };

package/dist/decorators/InverseRelation.js

@@ -10,7 +10,11 @@ function InverseRelation(inversionModel, sourceModel, relationOptions = null) {
                 ...relationOptions,
                 key,
                 inversionModel: model,
-                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`
+                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`,
+                // Generate a unique relation name if one is not provided
+                relationName: relationOptions && relationOptions.relationName ?
+                    relationOptions.relationName.toLowerCase() :
+                    `${model._collection}_${key}_${source._collection}`.toLowerCase()
             };
             return metaOpts;
         });

package/dist/decorators/RWSCollection.d.ts

@@ -1,9 +1,16 @@
 import { OpModelType } from "../models/_model";
+export interface ISuperTagData {
+    tagType: string;
+    fields: string[];
+    map: string;
+}
 export interface IRWSCollectionOpts {
     relations?: {
         [key: string]: boolean;
     };
     ignored_keys?: string[];
+    noId?: boolean;
+    superTags?: ISuperTagData[];
 }
 export interface IRWSCollectionMeta {
     collectionName: string;

package/dist/decorators/RWSCollection.js

@@ -11,6 +11,12 @@ function RWSCollection(collectionName, options) {
         if (options && options.ignored_keys) {
             target._CUT_KEYS = options.ignored_keys;
         }
+        if (options && options.noId) {
+            target._NO_ID = options.noId;
+        }
+        if (options && options.superTags && options.superTags.length) {
+            target._SUPER_TAGS = options.superTags;
+        }
         Reflect.defineMetadata(`RWSCollection`, metaOpts, target);
     };
 }

package/dist/decorators/Relation.d.ts

@@ -1,19 +1,21 @@
 import 'reflect-metadata';
 import { RWSModel, OpModelType } from '../models/_model';
-type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
-interface IRelationOpts {
+export type CascadingSetup = 'Cascade' | 'Restrict' | 'NoAction' | 'SetNull';
+export interface IRelationOpts {
     required?: boolean;
     key: string;
     relationField: string;
     relatedToField?: string;
+    mappingName?: string;
     relatedTo: OpModelType<RWSModel<any>>;
     many?: boolean;
     embed?: boolean;
-    cascade: {
-        onDelete: CascadingSetup;
-        onUpdate: CascadingSetup;
+    useUuid?: boolean;
+    relationName?: string;
+    cascade?: {
+        onDelete?: CascadingSetup;
+        onUpdate?: CascadingSetup;
     };
 }
 declare function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions?: Partial<IRelationOpts>): (target: any, key: string) => void;
 export default Relation;
-export { IRelationOpts };

package/dist/decorators/Relation.js

@@ -12,8 +12,15 @@ function Relation(theModel, relationOptions = _DEFAULTS) {
                 cascade: relationOptions.cascade || _DEFAULTS.cascade,
                 relatedTo,
                 relationField: relationOptions.relationField ? relationOptions.relationField : relatedTo._collection + '_id',
-                key
+                key,
+                // Generate a unique relation name if one is not provided
+                relationName: relationOptions.relationName ?
+                    relationOptions.relationName.toLowerCase() :
+                    `${target.constructor.name.toLowerCase()}_${key}_${relatedTo._collection.toLowerCase()}`
             };
+            if (relationOptions.required) {
+                metaOpts.cascade.onDelete = 'Restrict';
+            }
             return metaOpts;
         });
         // Store both the promise and the key information

package/dist/decorators/TrackType.d.ts

@@ -1,20 +1,8 @@
 import 'reflect-metadata';
-import { OpModelType } from '../models/interfaces/OpModelType';
-interface ITrackerOpts {
-    required?: boolean;
-    isArray?: boolean;
-    relationField?: string;
-    relatedToField?: string;
-    relatedTo?: OpModelType<any>;
-    inversionModel?: OpModelType<any>;
-    relationName?: string;
-}
-interface IMetaOpts extends ITrackerOpts {
+import { ITrackerOpts } from '../models/interfaces/ITrackerOpts';
+export interface ITrackerMetaOpts extends ITrackerOpts {
     type: any;
     tags: string[];
-    required: boolean;
-    isArray: boolean;
 }
 declare function TrackType(type: any, opts?: ITrackerOpts | null, tags?: string[]): (target: any, key: string) => void;
 export default TrackType;
-export { IMetaOpts, ITrackerOpts };

package/dist/decorators/TrackType.js

@@ -30,6 +30,13 @@ function TrackType(type, opts = null, tags = []) {
     if (opts.inversionModel) {
         metaOpts.inversionModel = opts.inversionModel;
     }
+    // Copy dbOptions if present
+    if (opts.dbOptions) {
+        metaOpts.dbOptions = opts.dbOptions;
+    }
+    if (opts.unique) {
+        metaOpts.unique = opts.unique;
+    }
     //const resolvedType = typeof type === 'function' ? type() : type;   
     if (type._collection) {
         metaOpts.type = type;

package/dist/decorators/TypeFunctions.d.ts

@@ -0,0 +1,44 @@
+import 'reflect-metadata';
+import { ITrackerOpts } from './TrackType';
+/**
+ * Type function options interface
+ */
+interface ITypeFunctionOpts extends ITrackerOpts {
+}
+/**
+ * String type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+declare function StringType(optsOrRequired?: ITypeFunctionOpts | boolean): PropertyDecorator;
+/**
+ * Number type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+declare function NumberType(optsOrRequired?: ITypeFunctionOpts | boolean): PropertyDecorator;
+/**
+ * Boolean type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+declare function BooleanType(optsOrRequired?: ITypeFunctionOpts | boolean): PropertyDecorator;
+/**
+ * Date type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+declare function DateType(optsOrRequired?: ITypeFunctionOpts | boolean): PropertyDecorator;
+/**
+ * Object type function (maps to JSON in databases)
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+declare function ObjectType(optsOrRequired?: ITypeFunctionOpts | boolean): PropertyDecorator;
+/**
+ * Array type function
+ * @param itemType Type of array items
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+declare function ArrayType(itemType: any, optsOrRequired?: ITypeFunctionOpts | boolean): PropertyDecorator;
+/**
+ * ID type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+declare function IdType(optsOrRequired?: ITypeFunctionOpts | boolean): PropertyDecorator;
+export { StringType, NumberType, BooleanType, DateType, ObjectType, ArrayType, IdType, ITypeFunctionOpts };

package/dist/decorators/TypeFunctions.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = StringType;
+exports.NumberType = NumberType;
+exports.BooleanType = BooleanType;
+exports.DateType = DateType;
+exports.ObjectType = ObjectType;
+exports.ArrayType = ArrayType;
+exports.IdType = IdType;
+require("reflect-metadata");
+const TrackType_1 = __importDefault(require("./TrackType"));
+/**
+ * String type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+function StringType(optsOrRequired) {
+    var _a, _b, _c, _d, _e, _f;
+    let opts = {};
+    if (typeof optsOrRequired === 'boolean') {
+        opts.required = optsOrRequired;
+    }
+    else if (optsOrRequired) {
+        opts = optsOrRequired;
+    }
+    const tags = [];
+    // Add database-specific tags based on options
+    if ((_b = (_a = opts.dbOptions) === null || _a === void 0 ? void 0 : _a.mysql) === null || _b === void 0 ? void 0 : _b.useText) {
+        tags.push('db.Text');
+    }
+    else if ((_d = (_c = opts.dbOptions) === null || _c === void 0 ? void 0 : _c.mysql) === null || _d === void 0 ? void 0 : _d.maxLength) {
+        tags.push(`db.VarChar(${opts.dbOptions.mysql.maxLength})`);
+    }
+    if ((_f = (_e = opts.dbOptions) === null || _e === void 0 ? void 0 : _e.postgres) === null || _f === void 0 ? void 0 : _f.useText) {
+        tags.push('db.Text');
+    }
+    // Return a property decorator that calls TrackType
+    return function (target, propertyKey) {
+        if (typeof propertyKey === 'string') {
+            (0, TrackType_1.default)(String, opts, tags)(target, propertyKey);
+        }
+    };
+}
+/**
+ * Number type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+function NumberType(optsOrRequired) {
+    let opts = {};
+    if (typeof optsOrRequired === 'boolean') {
+        opts.required = optsOrRequired;
+    }
+    else if (optsOrRequired) {
+        opts = optsOrRequired;
+    }
+    // Return a property decorator that calls TrackType
+    return function (target, propertyKey) {
+        if (typeof propertyKey === 'string') {
+            (0, TrackType_1.default)(Number, opts)(target, propertyKey);
+        }
+    };
+}
+/**
+ * Boolean type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+function BooleanType(optsOrRequired) {
+    let opts = {};
+    if (typeof optsOrRequired === 'boolean') {
+        opts.required = optsOrRequired;
+    }
+    else if (optsOrRequired) {
+        opts = optsOrRequired;
+    }
+    // Return a property decorator that calls TrackType
+    return function (target, propertyKey) {
+        if (typeof propertyKey === 'string') {
+            (0, TrackType_1.default)(Boolean, opts)(target, propertyKey);
+        }
+    };
+}
+/**
+ * Date type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+function DateType(optsOrRequired) {
+    let opts = {};
+    if (typeof optsOrRequired === 'boolean') {
+        opts.required = optsOrRequired;
+    }
+    else if (optsOrRequired) {
+        opts = optsOrRequired;
+    }
+    // Return a property decorator that calls TrackType
+    return function (target, propertyKey) {
+        if (typeof propertyKey === 'string') {
+            (0, TrackType_1.default)(Date, opts)(target, propertyKey);
+        }
+    };
+}
+/**
+ * Object type function (maps to JSON in databases)
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+function ObjectType(optsOrRequired) {
+    let opts = {};
+    if (typeof optsOrRequired === 'boolean') {
+        opts.required = optsOrRequired;
+    }
+    else if (optsOrRequired) {
+        opts = optsOrRequired;
+    }
+    // Return a property decorator that calls TrackType
+    return function (target, propertyKey) {
+        if (typeof propertyKey === 'string') {
+            (0, TrackType_1.default)(Object, opts)(target, propertyKey);
+        }
+    };
+}
+/**
+ * Array type function
+ * @param itemType Type of array items
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+function ArrayType(itemType, optsOrRequired) {
+    let opts = { isArray: true };
+    if (typeof optsOrRequired === 'boolean') {
+        opts.required = optsOrRequired;
+    }
+    else if (optsOrRequired) {
+        opts = { ...optsOrRequired, isArray: true };
+    }
+    // Return a property decorator that calls TrackType
+    return function (target, propertyKey) {
+        if (typeof propertyKey === 'string') {
+            (0, TrackType_1.default)(itemType, opts)(target, propertyKey);
+        }
+    };
+}
+/**
+ * ID type function
+ * @param optsOrRequired Options object or boolean indicating if field is required
+ */
+function IdType(optsOrRequired) {
+    var _a, _b, _c, _d;
+    let opts = {};
+    if (typeof optsOrRequired === 'boolean') {
+        opts.required = optsOrRequired;
+    }
+    else if (optsOrRequired) {
+        opts = optsOrRequired;
+    }
+    const tags = ['id'];
+    // Add database-specific tags based on options
+    if ((_b = (_a = opts.dbOptions) === null || _a === void 0 ? void 0 : _a.postgres) === null || _b === void 0 ? void 0 : _b.useUuid) {
+        tags.push('default(uuid())');
+    }
+    else if ((_d = (_c = opts.dbOptions) === null || _c === void 0 ? void 0 : _c.mysql) === null || _d === void 0 ? void 0 : _d.useUuid) {
+        tags.push('default(uuid())');
+    }
+    else {
+        tags.push('default(autoincrement())');
+    }
+    // Return a property decorator that calls TrackType
+    return function (target, propertyKey) {
+        var _a, _b, _c, _d;
+        if (typeof propertyKey === 'string') {
+            const type = ((_b = (_a = opts.dbOptions) === null || _a === void 0 ? void 0 : _a.postgres) === null || _b === void 0 ? void 0 : _b.useUuid) || ((_d = (_c = opts.dbOptions) === null || _c === void 0 ? void 0 : _c.mysql) === null || _d === void 0 ? void 0 : _d.useUuid) ? String : Number;
+            (0, TrackType_1.default)(type, opts, tags)(target, propertyKey);
+        }
+    };
+}

package/dist/decorators/index.d.ts

@@ -1,5 +1,7 @@
 import InverseRelation from './InverseRelation';
 import Relation from './Relation';
-import TrackType, { IMetaOpts } from './TrackType';
+import TrackType, { ITrackerMetaOpts } from './TrackType';
 import InverseTimeSeries from './InverseTimeSeries';
-export { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts };
+import IdType from './IdType';
+import { ITrackerOpts } from '../models/interfaces/ITrackerOpts';
+export { InverseRelation, Relation, TrackType, IdType, InverseTimeSeries, ITrackerMetaOpts, ITrackerOpts };

package/dist/decorators/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = void 0;
+exports.InverseTimeSeries = exports.IdType = exports.TrackType = exports.Relation = exports.InverseRelation = void 0;
 const InverseRelation_1 = __importDefault(require("./InverseRelation"));
 exports.InverseRelation = InverseRelation_1.default;
 const Relation_1 = __importDefault(require("./Relation"));
@@ -12,3 +12,5 @@ const TrackType_1 = __importDefault(require("./TrackType"));
 exports.TrackType = TrackType_1.default;
 const InverseTimeSeries_1 = __importDefault(require("./InverseTimeSeries"));
 exports.InverseTimeSeries = InverseTimeSeries_1.default;
+const IdType_1 = __importDefault(require("./IdType"));
+exports.IdType = IdType_1.default;

package/dist/helper/DbHelper.d.ts

@@ -1,12 +1,83 @@
-import { IDbConfigHandler, IDbConfigParams, IdGeneratorOptions } from '../types/DbConfigHandler';
-import { IMetaOpts, OpModelType } from '../models/_model';
+import { IDbConfigHandler, IDbConfigParams } from '../types/DbConfigHandler';
+import { OpModelType } from '../models/_model';
 import { DBService } from '../services/DBService';
+import { IIdMetaOpts } from '../decorators/IdType';
+/**
+ * Database helper class
+ *
+ * This class provides a facade for the database helper modules.
+ * It delegates to the specialized modules for specific functionality.
+ */
 export declare class DbHelper {
+    /**
+     * The environment variable name for the Prisma database URL
+     */
     static dbUrlVarName: string;
+    /**
+     * Install Prisma with the generated schema
+     * @param configService The configuration service
+     * @param dbService The database service
+     * @param leaveFile Whether to leave the schema file after generation
+     */
     static installPrisma(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
-    static generateId(dbType: IDbConfigParams['db_type'], options?: IdGeneratorOptions): string;
-    static detectInstaller(): string;
+    /**
+     * Push database models to the database
+     * @param configService The configuration service
+     * @param dbService The database service
+     * @param leaveFile Whether to leave the schema file after generation
+     */
     static pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile?: boolean): Promise<void>;
+    /**
+     * Generate model sections for the schema
+     * @param model The model to generate a section for
+     * @param configService The configuration service
+     * @returns The model section
+     */
     static generateModelSections(model: OpModelType<any>, configService: IDbConfigHandler): Promise<string>;
-    static toConfigCase(modelType: IMetaOpts): string;
+    /**
+     * Generate the base schema for Prisma
+     * @param dbType The database type
+     * @param dbUrl The database URL
+     * @returns The base schema
+     */
+    static generateBaseSchema(dbType: string, dbUrl: string): string;
+    /**
+     * Get the directory and path for the Prisma schema file
+     */
+    static getSchemaDir(): [string, string];
+    /**
+     * Detect the package installer (yarn or npx)
+     */
+    static detectInstaller(): string;
+    /**
+     * Generate an ID field based on the database type
+     */
+    static generateId(dbType: IDbConfigParams['db_type'], modelMeta: Record<string, {
+        annotationType: string;
+        metadata: IIdMetaOpts;
+    }>): string;
+    /**
+     * Convert a JavaScript type to a Prisma schema type
+     */
+    static toConfigCase(modelType: any, dbType?: string): string;
+    /**
+     * Process type functions metadata to extract database-specific options
+     */
+    static processTypeOptions(metadata: any, dbType: string): string[];
+    /**
+     * Mark a relation between two models
+     */
+    static markRelation(relationKey: string, inverse?: boolean): void;
+    /**
+     * Complete a relation between two models
+     */
+    static completeRelation(relationKey: string, index: number, inverse?: boolean): void;
+    /**
+     * Get a unique counter for a relation between two models
+     */
+    static getRelationCounter(relationKey: string, inverse?: boolean): number;
+    /**
+     * Generate a shortened relation name to stay within database limits
+     */
+    static getShortenedRelationName(modelName: string, relatedModelName: string, index: number): string;
 }