@rws-framework/db 3.2.0 → 3.3.0

package/dist/decorators/IdType.js

@@ -3,6 +3,12 @@ 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 };
+    if (opts && opts.dbOptions) {
+        metaOpts.dbOptions = opts.dbOptions;
+    }
+    if (opts && opts.noAuto) {
+        metaOpts.noAuto = opts.noAuto;
+    }
     return function (target, key) {
         Reflect.defineMetadata(`IdType:${key}`, metaOpts, target);
     };

package/dist/decorators/InverseRelation.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const ModelUtils_1 = require("../models/utils/ModelUtils");
 function guessForeignKey(inversionModel, bindingModel, decoratorsData) {
-    var _a;
     let key = null;
     let defaultKey = `${bindingModel._collection}_id`;
     const relDecorators = {};
@@ -21,7 +20,7 @@ function guessForeignKey(inversionModel, bindingModel, decoratorsData) {
         }
     }
     for (const relKey of Object.keys(relDecorators)) {
-        const prodMeta = (_a = relDecorators[relKey]) === null || _a === void 0 ? void 0 : _a.metadata;
+        const prodMeta = relDecorators[relKey]?.metadata;
         if (prodMeta && prodMeta.relatedTo._collection === bindingModel._collection) {
             return prodMeta.relationField;
         }
@@ -41,8 +40,8 @@ function InverseRelation(inversionModel, sourceModel, relationOptions = null) {
                 foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : guessForeignKey(model, source, decoratorsData),
                 // Generate a unique relation name if one is not provided
                 relationName: relationOptions && relationOptions.relationName ?
-                    relationOptions.relationName.toLowerCase() :
-                    `${model._collection}_${key}_${source._collection}`.toLowerCase()
+                    relationOptions.relationName :
+                    null
             };
             return metaOpts;
         });

package/dist/decorators/Relation.js

@@ -16,8 +16,8 @@ function Relation(theModel, relationOptions = _DEFAULTS) {
                 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()}`
+                    relationOptions.relationName :
+                    null
             };
             if (relationOptions.required) {
                 metaOpts.cascade.onDelete = 'Restrict';

package/dist/decorators/TrackType.js

@@ -8,10 +8,10 @@ function TrackType(type, opts = null, tags = []) {
             isArray: false
         };
     }
-    if (!(opts === null || opts === void 0 ? void 0 : opts.required)) {
+    if (!opts?.required) {
         opts.required = false;
     }
-    if (!(opts === null || opts === void 0 ? void 0 : opts.isArray)) {
+    if (!opts?.isArray) {
         opts.isArray = false;
     }
     const required = opts.required;

package/dist/helper/DbHelper.d.ts

@@ -60,7 +60,7 @@ export declare class DbHelper {
     /**
      * Convert a JavaScript type to a Prisma schema type
      */
-    static toConfigCase(modelType: any, dbType?: string): string;
+    static toConfigCase(modelType: any, dbType?: IDbConfigParams['db_type']): string;
     /**
      * Process type functions metadata to extract database-specific options
      */

package/dist/helper/DbHelper.js

@@ -10,6 +10,10 @@ const db_1 = require("./db");
  * It delegates to the specialized modules for specific functionality.
  */
 class DbHelper {
+    /**
+     * The environment variable name for the Prisma database URL
+     */
+    static dbUrlVarName = db_1.SchemaGenerator.dbUrlVarName;
     /**
      * Install Prisma with the generated schema
      * @param configService The configuration service
@@ -107,7 +111,3 @@ class DbHelper {
     }
 }
 exports.DbHelper = DbHelper;
-/**
- * The environment variable name for the Prisma database URL
- */
-DbHelper.dbUrlVarName = db_1.SchemaGenerator.dbUrlVarName;

package/dist/helper/db/relation-manager.js

@@ -5,6 +5,7 @@ exports.RelationManager = void 0;
  * Manages database relations for schema generation
  */
 class RelationManager {
+    static allRelations = new Map();
     /**
      * Mark a relation between two models
      * @param relationKey A unique key for the relation
@@ -102,4 +103,3 @@ class RelationManager {
     }
 }
 exports.RelationManager = RelationManager;
-RelationManager.allRelations = new Map();

package/dist/helper/db/schema-generator.js

@@ -11,10 +11,13 @@ const _model_1 = require("../../models/_model");
 const utils_1 = require("./utils");
 const type_converter_1 = require("./type-converter");
 const relation_manager_1 = require("./relation-manager");
+const _EXECUTE_PRISMA_CMD = true;
+const _REMOVE_SCHEMA_FILE = true;
 /**
  * Handles Prisma schema generation
  */
 class SchemaGenerator {
+    static dbUrlVarName = 'PRISMA_DB_URL';
     /**
      * Generate the base schema for Prisma
      * @param dbType The database type
@@ -39,21 +42,31 @@ datasource db {
      * @returns The model section
      */
     static async generateModelSections(model, configService) {
-        var _a, _b;
         let section = '';
         const modelMetadatas = await _model_1.RWSModel.getModelAnnotations(model);
         const dbType = configService.get('db_type') || 'mongodb';
         const modelName = model._collection;
         section += `model ${modelName} {\n`;
-        if (!model._NO_ID) {
+        let hasIdType = false;
+        let idFieldName;
+        for (const someModelMetaKey in modelMetadatas) {
+            const isIdTyped = modelMetadatas[someModelMetaKey].annotationType === 'IdType';
+            if (isIdTyped) {
+                hasIdType = true;
+                idFieldName = someModelMetaKey;
+            }
+        }
+        let idGenerated = false;
+        if (!model._NO_ID && !hasIdType) {
             section += `\t${utils_1.DbUtils.generateId(dbType, modelMetadatas)}\n`;
+            idGenerated = true;
         }
         for (const key in modelMetadatas) {
             const modelMetadata = modelMetadatas[key].metadata;
             let requiredString = modelMetadata.required ? '' : '?';
             const annotationType = modelMetadatas[key].annotationType;
             let indexedId = false;
-            if (model._NO_ID) {
+            if (model._NO_ID || hasIdType) {
                 indexedId = true;
                 requiredString = '';
             }
@@ -65,17 +78,17 @@ datasource db {
                 const relatedModel = relationMeta.relatedTo;
                 const isMany = relationMeta.many;
                 const cascadeOpts = [];
-                if ((_a = relationMeta.cascade) === null || _a === void 0 ? void 0 : _a.onDelete) {
+                if (relationMeta.cascade?.onDelete) {
                     cascadeOpts.push(`onDelete: ${relationMeta.cascade.onDelete}`);
                 }
-                if ((_b = relationMeta.cascade) === null || _b === void 0 ? void 0 : _b.onUpdate) {
+                if (relationMeta.cascade?.onUpdate) {
                     cascadeOpts.push(`onUpdate: ${relationMeta.cascade.onUpdate}`);
                 }
                 const relatedModelName = relatedModel._collection;
                 const relationKey = [modelName, relatedModelName].join('_');
                 const relationIndex = relation_manager_1.RelationManager.getRelationCounter(relationKey);
-                const relationName = relation_manager_1.RelationManager.getShortenedRelationName(modelName, relatedModelName, relationIndex);
-                const mapName = relationName;
+                const relationName = relationMeta.relationName ? relationMeta.relationName : null;
+                const mapName = relationMeta.mappingName ? relationMeta.mappingName : null;
                 const relatedModelMetadatas = await _model_1.RWSModel.getModelAnnotations(relatedModel);
                 const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
                 const relatedToField = modelMetadata.relatedToField || 'id';
@@ -86,10 +99,10 @@ datasource db {
                 const cascadeStr = cascadeOpts.length ? `, ${cascadeOpts.join(', ')}` : '';
                 if (isMany) {
                     // Add an inverse field to the related model if it doesn't exist
-                    section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
+                    section += `\t${key} ${relatedModel._collection}[] @relation(${relationName ? `"${relationName}", ` : ''}fields: [${relationFieldName}], references: [${relatedToField}]${mapName ? `, map: "${mapName}"` : ''}${cascadeStr})\n`;
                 }
                 else {
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
+                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation(${relationName ? `"${relationName}", ` : ''}fields: [${relationFieldName}], references: [${relatedToField}]${mapName ? `, map: "${mapName}"` : ''}${cascadeStr})\n`;
                     if (!bindingFieldExists) {
                         const relatedFieldMeta = relatedModelMetadatas[relatedToField];
                         if (!relatedFieldMeta.metadata.required) {
@@ -131,8 +144,11 @@ datasource db {
                 const relationKey = [relatedModelName, modelName].join('_');
                 const relationIndex = relation_manager_1.RelationManager.getRelationCounter(relationKey, true);
                 const relationName = relation_manager_1.RelationManager.getShortenedRelationName(relatedModelName, modelName, relationIndex);
-                const mapName = relationName;
-                section += `\t${key} ${relationMeta.inversionModel._collection}[] @relation("${relationName}", map: "${mapName}")\n`;
+                let relationTag = '';
+                if (relationMeta.relationName) {
+                    relationTag = ` @relation("${relationMeta.relationName}")`;
+                }
+                section += `\t${key} ${relationMeta.inversionModel._collection}[]${relationTag}\n`;
                 relation_manager_1.RelationManager.completeRelation(relationKey, relationIndex, true);
             }
             else if (annotationType === 'InverseTimeSeries') {
@@ -151,10 +167,16 @@ datasource db {
                     section += `\t${key} String[]\n`;
                 }
             }
-            else if (annotationType === 'TrackType') {
+            else {
                 const trackMeta = modelMetadata;
-                const tags = trackMeta.tags.map((item) => '@' + item);
-                if (key === 'id' && model._NO_ID && !model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes('id'))) {
+                const trackTags = trackMeta.tags || [];
+                const tags = trackTags.map((item) => '@' + item);
+                const isNoIdBehavior = model._NO_ID || idFieldName;
+                const isOverrideBehavior = (hasIdType && annotationType === 'IdType' && key === 'id' && idFieldName === 'id')
+                    ||
+                        (model._NO_ID && model._SUPER_TAGS.some(a => a.fields.includes('id')) && key === 'id');
+                if (key === 'id' &&
+                    isNoIdBehavior && !isOverrideBehavior) {
                     continue;
                 }
                 if (trackMeta.unique) {
@@ -173,7 +195,17 @@ datasource db {
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions(trackMeta, dbType);
                 tags.push(...dbSpecificTags);
-                section += `\t${key} ${type_converter_1.TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
+                const isIdTypeField = modelMetadatas[key].annotationType === 'IdType';
+                const fieldInUniqueSuperTag = model._SUPER_TAGS.some(st => st.tagType === 'unique' && st.fields.includes(key));
+                if (isIdTypeField) {
+                    requiredString = '';
+                }
+                let trackField = `${key} ${type_converter_1.TypeConverter.toConfigCase(trackMeta, dbType, key === 'id', isOverrideBehavior)}${requiredString} ${tags.join(' ')}`;
+                if (isIdTypeField) {
+                    trackField += utils_1.DbUtils.addIdPart(dbType, utils_1.DbUtils.doesUseUuid(modelMetadatas), trackMeta.noAuto);
+                    idGenerated = true;
+                }
+                section += `\t${trackField}\n`;
             }
         }
         if (model._SUPER_TAGS.length) {
@@ -250,11 +282,11 @@ datasource db {
                 fs_1.default.unlinkSync(schemaPath);
             }
             fs_1.default.writeFileSync(schemaPath, template);
-            await console_1.rwsShell.runCommand(`${utils_1.DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
-            leaveFile = false;
+            if (_EXECUTE_PRISMA_CMD)
+                await console_1.rwsShell.runCommand(`${utils_1.DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
             console.log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
-            if (!leaveFile) {
-                // fs.unlinkSync(schemaPath);
+            if (_REMOVE_SCHEMA_FILE) {
+                fs_1.default.unlinkSync(schemaPath);
             }
         }
     }
@@ -271,4 +303,3 @@ datasource db {
     }
 }
 exports.SchemaGenerator = SchemaGenerator;
-SchemaGenerator.dbUrlVarName = 'PRISMA_DB_URL';

package/dist/helper/db/type-converter.d.ts

@@ -1,6 +1,7 @@
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 import { ITrackerMetaOpts } from '../../models/_model';
 import { IIdMetaOpts } from 'src/decorators/IdType';
+import { IDbConfigParams } from 'src/types/DbConfigHandler';
 /**
  * Handles type conversion for database schema generation
  */
@@ -8,7 +9,7 @@ export declare class TypeConverter {
     /**
      * Convert a JavaScript type to a Prisma schema type
      */
-    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType?: string, isId?: boolean): string;
+    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType?: IDbConfigParams['db_type'], isId?: boolean, isIdOverride?: boolean): string;
     /**
      * Process type functions metadata to extract database-specific options
      * @param metadata The metadata from a type function

package/dist/helper/db/type-converter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeConverter = void 0;
+const utils_1 = require("./utils");
 /**
  * Handles type conversion for database schema generation
  */
@@ -8,7 +9,7 @@ class TypeConverter {
     /**
      * Convert a JavaScript type to a Prisma schema type
      */
-    static toConfigCase(modelType, dbType = 'mongodb', isId = false) {
+    static toConfigCase(modelType, dbType = 'mongodb', isId = false, isIdOverride = false) {
         const type = modelType.type;
         let input = type.name;
         // Handle basic types
@@ -30,6 +31,9 @@ class TypeConverter {
                 input = 'Int';
             }
         }
+        if (input == 'BigInt') {
+            input = 'BigInt';
+        }
         if (input == 'Object') {
             input = 'Json';
         }
@@ -53,8 +57,8 @@ class TypeConverter {
         const firstChar = input.charAt(0).toUpperCase();
         const restOfString = input.slice(1);
         let resultField = firstChar + restOfString;
-        if (isId) {
-            return dbType === 'mongodb' ? 'String' : 'Int';
+        if (isId && !isIdOverride) {
+            return utils_1.DbUtils.getDefaultPrismaType(dbType, false);
         }
         const trackerModelType = modelType;
         if (trackerModelType.isArray) {
@@ -81,7 +85,6 @@ class TypeConverter {
      * @returns Array of tags to apply to the field
      */
     static processTypeOptions(metadata, dbType) {
-        var _a, _b, _c, _d;
         const tags = [...(metadata.tags || [])];
         // Extract any database-specific options from the metadata
         // and convert them to appropriate Prisma schema tags
@@ -91,7 +94,7 @@ class TypeConverter {
                 let tag = null;
                 if (metadata.dbOptions.mysql.useType && !metadata.dbOptions.mysql.useText) {
                     const tagName = metadata.dbOptions.mysql.useType === 'VarChar' ? 'db.' + metadata.dbOptions.mysql.useType : metadata.dbOptions.mysql.useType;
-                    let tagParams = tagName === 'db.VarChar' && metadata.dbOptions.mysql.maxLength ? metadata.dbOptions.mysql.maxLength : (((_b = (_a = metadata.dbOptions.mysql) === null || _a === void 0 ? void 0 : _a.params) === null || _b === void 0 ? void 0 : _b.join(', ')) || '');
+                    let tagParams = tagName === 'db.VarChar' && metadata.dbOptions.mysql.maxLength ? metadata.dbOptions.mysql.maxLength : (metadata.dbOptions.mysql?.params?.join(', ') || '');
                     tag = `@${tagName}(${tagParams})`;
                 }
                 if (metadata.dbOptions.mysql.useText) {
@@ -100,7 +103,7 @@ class TypeConverter {
                 if (tag) {
                     tags.push(tag);
                 }
-                if (metadata.dbOptions.mysql.useUuid && ((_c = metadata.tags) === null || _c === void 0 ? void 0 : _c.includes('id'))) {
+                if (metadata.dbOptions.mysql.useUuid && metadata.tags?.includes('id')) {
                     tags.push('default(uuid())');
                 }
             }
@@ -109,7 +112,7 @@ class TypeConverter {
                 if (metadata.dbOptions.postgres.useText) {
                     tags.push('@db.Text');
                 }
-                if (metadata.dbOptions.postgres.useUuid && ((_d = metadata.tags) === null || _d === void 0 ? void 0 : _d.includes('id'))) {
+                if (metadata.dbOptions.postgres.useUuid && metadata.tags?.includes('id')) {
                     tags.push('@default(uuid())');
                     tags.push('@db.Uuid');
                 }

package/dist/helper/db/utils.d.ts

@@ -19,6 +19,13 @@ export declare class DbUtils {
         annotationType: string;
         metadata: IIdMetaOpts;
     }>, optional?: boolean): string;
+    static getDefaultPrismaType(dbType: IDbConfigParams['db_type'], useUuid: boolean): string;
+    static doesUseUuid(modelMeta: Record<string, {
+        annotationType: string;
+        metadata: IIdMetaOpts;
+    }>): boolean;
+    static addIdPart(dbType: IDbConfigParams['db_type'], useUuid: boolean, noAuto?: boolean): string;
+    static generateIdDefault(dbType: IDbConfigParams['db_type'], useUuid: boolean): string;
 }
 export declare const workspaceRootPath: string;
 export declare const moduleDirPath: string;

package/dist/helper/db/utils.js

@@ -35,8 +35,7 @@ class DbUtils {
      * Generate an ID field based on the database type
      */
     static generateId(dbType, modelMeta, optional = false) {
-        var _a, _b, _c, _d;
-        let useUuid = false;
+        let useUuid = this.doesUseUuid(modelMeta);
         let field = 'id';
         const tags = [];
         for (const key in modelMeta) {
@@ -47,50 +46,105 @@ class DbUtils {
                     const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions({ tags: [], dbOptions: modelMetadata.dbOptions }, dbType);
                     tags.push(...dbSpecificTags);
                     field = key;
-                    if ((_b = (_a = modelMetadata.dbOptions) === null || _a === void 0 ? void 0 : _a.mysql) === null || _b === void 0 ? void 0 : _b.useUuid) {
-                        useUuid = true;
-                    }
-                    if ((_d = (_c = modelMetadata.dbOptions) === null || _c === void 0 ? void 0 : _c.postgres) === null || _d === void 0 ? void 0 : _d.useUuid) {
-                        useUuid = true;
-                    }
-                    if (modelMetadata.type.name === 'String') {
-                        useUuid = true;
-                    }
                 }
             }
         }
-        let idString;
+        const idPrismaType = this.getDefaultPrismaType(dbType, useUuid);
         let reqStr = '';
         if (optional) {
             reqStr = '?';
         }
+        let idString = `${field} ${idPrismaType}${reqStr}`;
+        idString += this.addIdPart(dbType, useUuid, modelMeta[field].metadata.noAuto);
+        if (dbType === 'mongodb') {
+            tags.push('@map("_id")');
+            tags.push('@db.ObjectId');
+        }
+        if (tags.length) {
+            idString += ' ' + tags.join(' ');
+        }
+        if (!idString) {
+            throw new Error(`DB type "${dbType}" is not supported!`);
+        }
+        return idString;
+    }
+    static getDefaultPrismaType(dbType, useUuid) {
+        let idPrismaType = 'String';
         switch (dbType) {
-            case 'mongodb':
-                idString = `${field} String${reqStr} @id @default(auto()) @map("_id") @db.ObjectId`;
-                break;
             case 'mysql':
-                idString = useUuid
-                    ? `${field} String${reqStr} @id @default(uuid())`
-                    : `${field} Int${reqStr} @id @default(autoincrement())`;
+                if (useUuid) {
+                    idPrismaType = 'String';
+                }
+                else {
+                    idPrismaType = 'Int';
+                }
                 break;
             case 'postgresql':
             case 'postgres':
-                idString = useUuid
-                    ? `${field} String${reqStr} @id @default(uuid())`
-                    : `${field} Int${reqStr} @id @default(autoincrement())`;
+                if (useUuid) {
+                    idPrismaType = 'String';
+                }
+                else {
+                    idPrismaType = 'Int';
+                }
                 break;
             case 'sqlite':
-                idString = `${field} Int${reqStr} @id @default(autoincrement())`;
+                if (useUuid) {
+                    idPrismaType = 'String';
+                }
+                else {
+                    idPrismaType = 'Int';
+                }
                 break;
         }
-        if (tags.length) {
-            idString += ' ' + tags.join(' ');
+        return idPrismaType;
+    }
+    static doesUseUuid(modelMeta) {
+        let useUuid = false;
+        for (const key in modelMeta) {
+            const modelMetadata = modelMeta[key].metadata;
+            const annotationType = modelMeta[key].annotationType;
+            if (key !== 'id') {
+                if (annotationType == 'IdType') {
+                    if (modelMetadata.dbOptions?.mysql?.useUuid) {
+                        useUuid = true;
+                    }
+                    if (modelMetadata.dbOptions?.postgres?.useUuid) {
+                        useUuid = true;
+                    }
+                    if (modelMetadata.type.name === 'String') {
+                        useUuid = true;
+                    }
+                }
+            }
         }
-        if (!idString) {
-            throw new Error(`DB type "${dbType}" is not supported!`);
+        return useUuid;
+    }
+    static addIdPart(dbType, useUuid, noAuto = false) {
+        let idString = ` @id${!noAuto ? ` @default(${this.generateIdDefault(dbType, useUuid)})` : ''}`;
+        if (dbType === 'mongodb') {
+            idString += ' @map("_id")';
+            idString += ' @db.ObjectId';
         }
         return idString;
     }
+    static generateIdDefault(dbType, useUuid) {
+        switch (dbType) {
+            case 'mongodb':
+                return `auto()`;
+            case 'mysql':
+                return useUuid
+                    ? `uuid()`
+                    : `autoincrement()`;
+            case 'postgresql':
+            case 'postgres':
+                return useUuid
+                    ? `uuid()`
+                    : `autoincrement()`;
+            case 'sqlite':
+                return 'autoincrement()';
+        }
+    }
 }
 exports.DbUtils = DbUtils;
 exports.workspaceRootPath = workspaceRoot;

package/dist/models/core/RWSModel.js

@@ -17,6 +17,15 @@ const TimeSeriesUtils_1 = require("../utils/TimeSeriesUtils");
 const ModelUtils_1 = require("../utils/ModelUtils");
 const HydrateUtils_1 = require("../utils/HydrateUtils");
 class RWSModel {
+    static services = {};
+    id;
+    static _collection = null;
+    static _RELATIONS = {};
+    static _NO_ID = false;
+    static _SUPER_TAGS = [];
+    static _BANNED_KEYS = ['_collection'];
+    static allModels = [];
+    static _CUT_KEYS = [];
     constructor(data = null) {
         if (!this.getCollection()) {
             throw new Error('Model must have a collection defined');
@@ -110,12 +119,11 @@ class RWSModel {
         return RelationUtils_1.RelationUtils.getRelationManyMeta(model, classFields);
     }
     static async paginate(paginateParams, findParams) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {
@@ -231,12 +239,11 @@ class RWSModel {
         return await this.services.dbService.watchCollection(collection, preRun);
     }
     static async findOneBy(findParams) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
         this.checkForInclusionWithThrow('');
         const collection = Reflect.get(this, '_collection');
         const dbData = await this.services.dbService.findOneBy(collection, conditions, fields, ordering, allowRelations);
@@ -247,11 +254,10 @@ class RWSModel {
         return null;
     }
     static async find(id, findParams = null) {
-        var _a, _b, _c, _d;
-        const ordering = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _a !== void 0 ? _a : null;
-        const fields = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _b !== void 0 ? _b : null;
-        const allowRelations = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _c !== void 0 ? _c : true;
-        const fullData = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _d !== void 0 ? _d : false;
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         const dbData = await this.services.dbService.findOneBy(collection, { id }, fields, ordering, allowRelations);
@@ -262,16 +268,15 @@ class RWSModel {
         return null;
     }
     static async findBy(findParams) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {
-            const paginateParams = (findParams === null || findParams === void 0 ? void 0 : findParams.pagination) ? findParams === null || findParams === void 0 ? void 0 : findParams.pagination : undefined;
+            const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
             const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
             if (dbData.length) {
                 const instanced = [];
@@ -327,14 +332,6 @@ class RWSModel {
     }
 }
 exports.RWSModel = RWSModel;
-RWSModel.services = {};
-RWSModel._collection = null;
-RWSModel._RELATIONS = {};
-RWSModel._NO_ID = false;
-RWSModel._SUPER_TAGS = [];
-RWSModel._BANNED_KEYS = ['_collection'];
-RWSModel.allModels = [];
-RWSModel._CUT_KEYS = [];
 __decorate([
     (0, decorators_1.TrackType)(String),
     __metadata("design:type", Object)

package/dist/models/interfaces/IIdTypeOpts.d.ts

@@ -1,3 +1,5 @@
 import { IDbOpts } from "./IDbOpts";
 export interface IIdTypeOpts extends IDbOpts {
+    unique?: boolean | string;
+    noAuto?: boolean;
 }

package/dist/models/interfaces/ITrackerOpts.d.ts

@@ -9,4 +9,5 @@ export interface ITrackerOpts extends IDbOpts {
     relatedTo?: OpModelType<any>;
     inversionModel?: OpModelType<any>;
     relationName?: string;
+    noAuto?: boolean;
 }

package/dist/models/utils/ModelUtils.js

@@ -6,8 +6,15 @@ class ModelUtils {
     static async getModelAnnotations(constructor) {
         const annotationsData = {};
         const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
+        const filteredMetaKeys = metadataKeys.filter((metaKey) => {
+            const [annotationType, annotatedField] = metaKey.split(':');
+            if (annotationType === 'TrackType' && annotatedField === 'id' && metadataKeys.includes('IdType:' + annotatedField)) {
+                return false;
+            }
+            return true;
+        });
         // Process all metadata keys and collect promises
-        const metadataPromises = metadataKeys.map(async (fullKey) => {
+        const metadataPromises = filteredMetaKeys.map(async (fullKey) => {
             const [annotationType, propertyKey] = fullKey.split(':');
             const metadata = Reflect.getMetadata(fullKey, constructor.prototype);
             if (metadata) {

package/dist/models/utils/PaginationUtils.js

@@ -3,12 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PaginationUtils = void 0;
 class PaginationUtils {
     static async paginate(paginationParams = { page: 0, per_page: 50 }, findParams = {}) {
-        var _a, _b, _c, _d, _e;
-        const conditions = (_a = findParams === null || findParams === void 0 ? void 0 : findParams.conditions) !== null && _a !== void 0 ? _a : {};
-        const ordering = (_b = findParams === null || findParams === void 0 ? void 0 : findParams.ordering) !== null && _b !== void 0 ? _b : null;
-        const fields = (_c = findParams === null || findParams === void 0 ? void 0 : findParams.fields) !== null && _c !== void 0 ? _c : null;
-        const allowRelations = (_d = findParams === null || findParams === void 0 ? void 0 : findParams.allowRelations) !== null && _d !== void 0 ? _d : true;
-        const fullData = (_e = findParams === null || findParams === void 0 ? void 0 : findParams.fullData) !== null && _e !== void 0 ? _e : false;
+        const conditions = findParams?.conditions ?? {};
+        const ordering = findParams?.ordering ?? null;
+        const fields = findParams?.fields ?? null;
+        const allowRelations = findParams?.allowRelations ?? true;
+        const fullData = findParams?.fullData ?? false;
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {

package/dist/services/DBService.js

@@ -8,10 +8,12 @@ const client_1 = require("@prisma/client");
 const mongodb_1 = require("mongodb");
 const chalk_1 = __importDefault(require("chalk"));
 class DBService {
+    configService;
+    client;
+    opts = null;
+    connected = false;
     constructor(configService) {
         this.configService = configService;
-        this.opts = null;
-        this.connected = false;
     }
     connectToDB(opts = null) {
         if (opts) {
@@ -50,15 +52,13 @@ class DBService {
         return client;
     }
     async createBaseMongoClient() {
-        var _a;
-        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('db_url');
+        const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = DBService.baseClientConstruct(dbUrl);
         await client.connect();
         return client;
     }
     async createBaseMongoClientDB() {
-        var _a;
-        const dbName = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbName) || this.configService.get('db_name');
+        const dbName = this.opts?.dbName || this.configService.get('db_name');
         const client = await this.createBaseMongoClient();
         return [client, client.db(dbName)];
     }
@@ -151,8 +151,7 @@ class DBService {
         return retData;
     }
     async collectionExists(collection_name) {
-        var _a;
-        const dbUrl = ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.dbUrl) || this.configService.get('db_url');
+        const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = new mongodb_1.MongoClient(dbUrl);
         try {
             await client.connect();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/decorators/IdType.ts

@@ -8,7 +8,16 @@ export interface IIdMetaOpts extends IIdTypeOpts {
   
 function IdType(type: any, opts: IIdTypeOpts | null = null, tags: string[] = []) {   
     const metaOpts: IIdMetaOpts = { type, dbOptions: opts && opts.dbOptions ? opts.dbOptions : null };
-    return function(target: any, key: string) {          
+    
+    if(opts && opts.dbOptions){
+        metaOpts.dbOptions = opts.dbOptions;
+    }
+
+    if(opts && opts.noAuto){
+        metaOpts.noAuto = opts.noAuto;
+    }
+
+    return function(target: any, key: string) {                  
         Reflect.defineMetadata(`IdType:${key}`, metaOpts, target);
     };
 }

package/src/decorators/InverseRelation.ts

@@ -64,8 +64,8 @@ function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourc
                 foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : guessForeignKey(model, source, decoratorsData),
                 // Generate a unique relation name if one is not provided
                 relationName: relationOptions && relationOptions.relationName ?
-                    relationOptions.relationName.toLowerCase() :
-                    `${model._collection}_${key}_${source._collection}`.toLowerCase()
+                    relationOptions.relationName :
+                    null
             };
 
             return metaOpts;

package/src/decorators/Relation.ts

@@ -39,8 +39,8 @@ function Relation(theModel: () => OpModelType<RWSModel<any>>, relationOptions: P
                 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()}`
+                  relationOptions.relationName : 
+                  null
             };  
             
             if(relationOptions.required){

package/src/helper/DbHelper.ts

@@ -101,7 +101,7 @@ export class DbHelper {
     /**
      * Convert a JavaScript type to a Prisma schema type
      */
-    static toConfigCase(modelType: any, dbType: string = 'mongodb'): string {
+    static toConfigCase(modelType: any, dbType: IDbConfigParams['db_type'] = 'mongodb'): string {
         return TypeConverter.toConfigCase(modelType, dbType);
     }
 

package/src/helper/db/schema-generator.ts

@@ -15,6 +15,8 @@ import { RelationManager } from './relation-manager';
 import { ITrackerMetaOpts } from '../../decorators/TrackType';
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 
+const _EXECUTE_PRISMA_CMD = true;
+const _REMOVE_SCHEMA_FILE = true;
 
 /**
  * Handles Prisma schema generation
@@ -56,13 +58,28 @@ datasource db {
         const dbType = configService.get('db_type') || 'mongodb';
         const modelName: string = (model as any)._collection;
 
-        section += `model ${modelName} {\n`;       
+        section += `model ${modelName} {\n`;               
+
+        let hasIdType = false;  
+        let idFieldName: string;
+
+        for(const someModelMetaKey in modelMetadatas){
+            const isIdTyped = modelMetadatas[someModelMetaKey].annotationType === 'IdType';
+            if(isIdTyped){
+                hasIdType = true;
+                idFieldName = someModelMetaKey;
+            }
+        }
+
+        let idGenerated = false;      
+            
 
         if(
-            !model._NO_ID            
-        ){
-            section += `\t${DbUtils.generateId(dbType, modelMetadatas)}\n`;
-        }              
+            !model._NO_ID && !hasIdType            
+        ){                     
+            section += `\t${DbUtils.generateId(dbType, modelMetadatas)}\n`;     
+            idGenerated = true;
+        }                        
 
         for (const key in modelMetadatas) {
             const modelMetadata = modelMetadatas[key].metadata;
@@ -71,16 +88,15 @@ datasource db {
 
             let indexedId = false;
 
-            if(model._NO_ID){
+            if(model._NO_ID || hasIdType){
                 indexedId = true;
                 requiredString = '';
-            }
-                   
+            }                         
 
             if (key === 'id' && !indexedId) {
                 continue;
             }
-
+              
             if (annotationType === 'Relation') {
                 const relationMeta = modelMetadata as IRelationOpts;
 
@@ -100,8 +116,9 @@ datasource db {
                 const relationKey = [modelName, relatedModelName].join('_');
                 
                 const relationIndex = RelationManager.getRelationCounter(relationKey);
-                const relationName = RelationManager.getShortenedRelationName(modelName, relatedModelName, relationIndex);
-                const mapName = relationName; 
+                const relationName = relationMeta.relationName ? relationMeta.relationName : null;
+
+                const mapName = relationMeta.mappingName ? relationMeta.mappingName : null; 
 
                 const relatedModelMetadatas: Record<string, { annotationType: string, metadata: ITrackerMetaOpts }> = await RWSModel.getModelAnnotations(relatedModel);
                 const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField  : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
@@ -111,19 +128,19 @@ datasource db {
                 
                 if(modelMetadata.required === false){
                     requiredString = '?';
-                }
+                }               
 
                 const cascadeStr = cascadeOpts.length ? `, ${cascadeOpts.join(', ')}` : '' ;
 
                 if (isMany) {
                     // Add an inverse field to the related model if it doesn't exist
-                    section += `\t${key} ${relatedModel._collection}[] @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
-                } else {                    
-                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}"${cascadeStr})\n`;
+                    section += `\t${key} ${relatedModel._collection}[] @relation(${relationName ? `"${relationName}", ` : ''}fields: [${relationFieldName}], references: [${relatedToField}]${mapName ? `, map: "${mapName}"` : ''}${cascadeStr})\n`;
+                } else {                             
+                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation(${relationName ? `"${relationName}", ` : ''}fields: [${relationFieldName}], references: [${relatedToField}]${mapName ? `, map: "${mapName}"` : ''}${cascadeStr})\n`;
                     if(!bindingFieldExists){
                         const relatedFieldMeta = relatedModelMetadatas[relatedToField];
 
-                        if(!relatedFieldMeta.metadata.required){
+                        if(!relatedFieldMeta.metadata.required){                     
                             requiredString = '';
                         }
                         
@@ -163,10 +180,15 @@ datasource db {
                 const relationKey = [relatedModelName, modelName].join('_');
                 const relationIndex = RelationManager.getRelationCounter(relationKey, true);
 
-                const relationName = RelationManager.getShortenedRelationName(relatedModelName, modelName, relationIndex);
-                const mapName = relationName; 
+                const relationName = RelationManager.getShortenedRelationName(relatedModelName, modelName, relationIndex);                
+
+                let relationTag = '';
 
-                section += `\t${key} ${relationMeta.inversionModel._collection}[] @relation("${relationName}", map: "${mapName}")\n`;
+                if(relationMeta.relationName){
+                    relationTag = ` @relation("${relationMeta.relationName}")`;
+                }
+
+                section += `\t${key} ${relationMeta.inversionModel._collection}[]${relationTag}\n`;
                 
                 RelationManager.completeRelation(relationKey, relationIndex, true);
             } else if (annotationType === 'InverseTimeSeries') {
@@ -181,14 +203,22 @@ datasource db {
                 } else {
                     section += `\t${key} String[]\n`;
                 }
-            } else if (annotationType === 'TrackType') {
+            } else {
                 const trackMeta = modelMetadata as ITrackerMetaOpts;
-                const tags: string[] = trackMeta.tags.map((item: string) => '@' + item);  
-                
-                if(key === 'id' && model._NO_ID && !model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes('id'))){
+                const trackTags = trackMeta.tags || [];
+                const tags: string[] = trackTags.map((item: string) => '@' + item);  
+                             
+                const isNoIdBehavior = model._NO_ID || idFieldName;
+                const isOverrideBehavior = (hasIdType && annotationType === 'IdType' && key === 'id' && idFieldName === 'id') 
+                    || 
+                    (model._NO_ID && model._SUPER_TAGS.some(a => a.fields.includes('id')) && key === 'id');
+                                                                
+                if(key === 'id' && 
+                    isNoIdBehavior && !isOverrideBehavior               
+                ){                  
                     continue;
                 }
-       
+
                 if(trackMeta.unique){
                     const fieldDetail: string | null = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
                     tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
@@ -210,8 +240,21 @@ datasource db {
                 const dbSpecificTags = TypeConverter.processTypeOptions(trackMeta as { tags: string[], dbOptions: IDbOpts['dbOptions'] }, dbType);
                 tags.push(...dbSpecificTags);
          
+                const isIdTypeField = modelMetadatas[key].annotationType === 'IdType';                         
+                const fieldInUniqueSuperTag = model._SUPER_TAGS.some(st => st.tagType === 'unique' && st.fields.includes(key));
 
-                section += `\t${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
+                if(isIdTypeField){
+                    requiredString = '';
+                }        
+
+                let trackField = `${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id', isOverrideBehavior)}${requiredString} ${tags.join(' ')}`;
+
+                if(isIdTypeField){
+                    trackField += DbUtils.addIdPart(dbType, DbUtils.doesUseUuid(modelMetadatas), trackMeta.noAuto);
+                    idGenerated = true;                                   
+                }          
+
+                section += `\t${trackField}\n`;
             }
         }
 
@@ -319,13 +362,14 @@ datasource db {
 
             fs.writeFileSync(schemaPath, template);
 
+            if(_EXECUTE_PRISMA_CMD)
             await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma generate --schema=${schemaPath}`, process.cwd());
 
-            leaveFile = false;
+            
             console.log(chalk.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
 
-            if (!leaveFile) {
-                // fs.unlinkSync(schemaPath);
+            if (_REMOVE_SCHEMA_FILE) {
+                fs.unlinkSync(schemaPath);
             }
         }
     }

package/src/helper/db/type-converter.ts

@@ -1,6 +1,8 @@
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
 import { ITrackerMetaOpts } from '../../models/_model';
 import { IIdMetaOpts } from 'src/decorators/IdType';
+import { DbUtils } from './utils';
+import { IDbConfigParams } from 'src/types/DbConfigHandler';
 
 /**
  * Handles type conversion for database schema generation
@@ -9,7 +11,7 @@ export class TypeConverter {
     /**
      * Convert a JavaScript type to a Prisma schema type
      */
-    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType: string = 'mongodb', isId: boolean = false): string {
+    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType: IDbConfigParams['db_type'] = 'mongodb', isId: boolean = false, isIdOverride: boolean = false): string {
         const type = modelType.type;
         let input = type.name;    
             
@@ -36,6 +38,10 @@ export class TypeConverter {
             }            
         }
 
+        if (input == 'BigInt') {
+            input = 'BigInt';
+        }
+
         if (input == 'Object') {
             input = 'Json';
         }
@@ -63,9 +69,9 @@ export class TypeConverter {
         const restOfString = input.slice(1);
         let resultField = firstChar + restOfString;
 
-        if(isId){
-            return dbType === 'mongodb' ? 'String' : 'Int';
-        }
+        if(isId && !isIdOverride){
+            return DbUtils.getDefaultPrismaType(dbType, false);
+        }      
 
         const trackerModelType = modelType as ITrackerMetaOpts;
 

package/src/helper/db/utils.ts

@@ -5,6 +5,7 @@ import { IDbConfigParams } from '../../types/DbConfigHandler';
 import { IIdMetaOpts, IIdTypeOpts } from '../../decorators/IdType';
 import { TypeConverter } from './type-converter';
 import { IDbOpts } from '../../models/interfaces/IDbOpts';
+import { ITrackerMetaOpts } from '../../models/_model';
 
 const workspaceRoot = rwsPath.findRootWorkspacePath();
 const moduleDir = path.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
@@ -41,78 +42,151 @@ export class DbUtils {
         dbType: IDbConfigParams['db_type'],
         modelMeta: Record<string, { annotationType: string, metadata: IIdMetaOpts }>,
         optional = false
-    ): string {        
-        let useUuid = false;
+    ): string {
+        let useUuid = this.doesUseUuid(modelMeta);
         let field = 'id';
         const tags: string[] = [];        
 
         for (const key in modelMeta) {
-            const modelMetadata: IIdMetaOpts = modelMeta[key].metadata;            
-            const annotationType: string = modelMeta[key].annotationType;            
+            const modelMetadata: IIdMetaOpts = modelMeta[key].metadata;
+            const annotationType: string = modelMeta[key].annotationType;
 
-            if(key !== 'id'){
-                if(annotationType == 'IdType'){     
+            if (key !== 'id') {
+                if (annotationType == 'IdType') {
                     const dbSpecificTags = TypeConverter.processTypeOptions({ tags: [], dbOptions: modelMetadata.dbOptions }, dbType);
-                    tags.push(...dbSpecificTags);                 
-                             
-                    field = key;
+                    tags.push(...dbSpecificTags);
+
+                    field = key;                   
+                }
+            }
+        }
+
+        const idPrismaType = this.getDefaultPrismaType(dbType, useUuid);
+      
+        let reqStr = '';
+
+        if (optional) {
+            reqStr = '?';
+        }
+
+        let idString: string = `${field} ${idPrismaType}${reqStr}`;
+
+        idString += this.addIdPart(dbType, useUuid, modelMeta[field].metadata.noAuto);
+
+        if(dbType === 'mongodb'){
+            tags.push('@map("_id")');
+            tags.push('@db.ObjectId');
+        }
+
+        if (tags.length) {
+            idString += ' ' + tags.join(' ');
+        }
+
+        if (!idString) {
+            throw new Error(`DB type "${dbType}" is not supported!`);
+        }
+
+
+        return idString;
+    }
+
+    static getDefaultPrismaType(dbType: IDbConfigParams['db_type'], useUuid: boolean): string 
+    {
+        let idPrismaType = 'String';
+
+        switch (dbType) {
+            case 'mysql':
+                if (useUuid) {
+                    idPrismaType = 'String';
+                } else {
+                    idPrismaType = 'Int';
+                }
+
+                break;
+
+            case 'postgresql':
+            case 'postgres':
+                if (useUuid) {
+                    idPrismaType = 'String';
+                } else {
+                    idPrismaType = 'Int';
+                }
+
+                break;
+
+            case 'sqlite':
+                if (useUuid) {
+                    idPrismaType = 'String';
+                } else {
+                    idPrismaType = 'Int';
+                }
+
+                break;
+        }
+
+        return idPrismaType;
+    }
 
-                    if(modelMetadata.dbOptions?.mysql?.useUuid){
+    static doesUseUuid(modelMeta: Record<string, { annotationType: string, metadata: IIdMetaOpts }>): boolean
+    {
+        let useUuid = false;
+       
+        for (const key in modelMeta) {
+            const modelMetadata: IIdMetaOpts = modelMeta[key].metadata;
+            const annotationType: string = modelMeta[key].annotationType;
+
+            if (key !== 'id') {
+                if (annotationType == 'IdType') {                                      
+                    if (modelMetadata.dbOptions?.mysql?.useUuid) {
                         useUuid = true;
                     }
 
-                    if(modelMetadata.dbOptions?.postgres?.useUuid){
+                    if (modelMetadata.dbOptions?.postgres?.useUuid) {
                         useUuid = true;
                     }
 
-                    if(modelMetadata.type.name === 'String'){
+                    if (modelMetadata.type.name === 'String') {
                         useUuid = true;
                     }
                 }
             }
         }
 
-        let idString: string;
-        
-        let reqStr = '';
+        return useUuid;
+    }
 
-        if(optional){
-            reqStr = '?';
+    static addIdPart(dbType: IDbConfigParams['db_type'], useUuid: boolean, noAuto: boolean = false): string
+    { 
+        let idString = ` @id${!noAuto ? ` @default(${this.generateIdDefault(dbType, useUuid)})` : ''}`;
+
+        if(dbType === 'mongodb'){
+            idString += ' @map("_id")';
+            idString += ' @db.ObjectId';            
         }
 
+        return idString;
+    }
+
+    static generateIdDefault(dbType: IDbConfigParams['db_type'], useUuid: boolean): string
+    {        
         switch (dbType) {
             case 'mongodb':
-                idString = `${field} String${reqStr} @id @default(auto()) @map("_id") @db.ObjectId`;
-                break;
+                return `auto()`;                
 
             case 'mysql':
-                idString = useUuid
-                    ? `${field} String${reqStr} @id @default(uuid())`
-                    : `${field} Int${reqStr} @id @default(autoincrement())`;
-                break;
+                return useUuid
+                    ? `uuid()`
+                    : `autoincrement()`;                
 
             case 'postgresql':
             case 'postgres':
-                idString = useUuid
-                    ? `${field} String${reqStr} @id @default(uuid())`
-                    : `${field} Int${reqStr} @id @default(autoincrement())`;
-                    break;    
+                return useUuid
+                    ? `uuid()`
+                    : `autoincrement()`;                
 
             case 'sqlite':
-                idString = `${field} Int${reqStr} @id @default(autoincrement())`;            
-                break;
-        }        
-
-        if(tags.length){
-            idString += ' '+tags.join(' ');
-        }
-
-        if(!idString){
-            throw new Error(`DB type "${dbType}" is not supported!`);
+                return 'autoincrement()';
         }
-
-
-        return idString;
     }
 }
 

package/src/models/interfaces/IIdTypeOpts.ts

@@ -1,4 +1,6 @@
 import { IDbOpts } from "./IDbOpts";
 
 export interface IIdTypeOpts extends IDbOpts {     
+    unique?: boolean | string;
+    noAuto?: boolean;
 }

package/src/models/interfaces/ITrackerOpts.ts

@@ -10,4 +10,5 @@ export interface ITrackerOpts extends IDbOpts {
     relatedTo?: OpModelType<any>,
     inversionModel?: OpModelType<any>,
     relationName?: string    
+    noAuto?: boolean;
   }

package/src/models/utils/ModelUtils.ts

@@ -6,9 +6,18 @@ export class ModelUtils {
         const annotationsData: Record<string, {annotationType: string, metadata: any}> = {};
     
         const metadataKeys = Reflect.getMetadataKeys(constructor.prototype);
+
+        const filteredMetaKeys = metadataKeys.filter((metaKey) => {
+            const [annotationType, annotatedField] = metaKey.split(':');
+            if(annotationType === 'TrackType' && annotatedField === 'id' && metadataKeys.includes('IdType:' + annotatedField)){
+                return false;
+            }
+
+            return true;
+        });
         
         // Process all metadata keys and collect promises
-        const metadataPromises = metadataKeys.map(async (fullKey: string) => {
+        const metadataPromises = filteredMetaKeys.map(async (fullKey: string) => {
             const [annotationType, propertyKey] = fullKey.split(':');
             const metadata = Reflect.getMetadata(fullKey, constructor.prototype);
     

package/tsconfig.json

@@ -3,7 +3,7 @@
       "baseUrl": ".",
       "experimentalDecorators": true,
       "emitDecoratorMetadata": true,
-      "target": "ES2018",
+      "target": "ES2022",
       "module": "commonjs",
       "moduleResolution": "node",
       "strict": true,