@rws-framework/db 3.2.0 → 3.3.1

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.1",
   "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

@@ -46,7 +46,7 @@ export class DbHelper {
     static async migrateDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
        
-        const [_, schemaPath] = DbUtils.getSchemaDir();
+        const [_, schemaPath] = DbUtils.getProcessedSchemaDir();
 
         await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma migrate dev --create-only --schema=${schemaPath}`, process.cwd());
     }
@@ -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);
             }
         }
     }
@@ -339,7 +383,7 @@ datasource db {
     static async pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
         process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
 
-        const [_, schemaPath] = DbUtils.getSchemaDir();
+        const [_, schemaPath] = DbUtils.getProcessedSchemaDir();
 
         await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd());
     }

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');
@@ -23,6 +24,13 @@ export class DbUtils {
         return [schemaDir, schemaPath];
     }
 
+    static getProcessedSchemaDir(): [string, string] {
+        const schemaDir = path.join(workspaceRoot, 'node_modules','.prisma', 'client');
+        const schemaPath = path.join(schemaDir, 'schema.prisma');
+
+        return [schemaDir, schemaPath];
+    }
+
     /**
      * Detect the package installer (yarn or npx)
      */
@@ -41,78 +49,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;
 
-                    if(modelMetadata.dbOptions?.mysql?.useUuid){
+            case 'postgresql':
+            case 'postgres':
+                if (useUuid) {
+                    idPrismaType = 'String';
+                } else {
+                    idPrismaType = 'Int';
+                }
+
+                break;
+
+            case 'sqlite':
+                if (useUuid) {
+                    idPrismaType = 'String';
+                } else {
+                    idPrismaType = 'Int';
+                }
+
+                break;
+        }
+
+        return idPrismaType;
+    }
+
+    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,