@rws-framework/db 3.1.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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
-const _DEFAULTS = { required: false, many: false, embed: false, cascade: { onDelete: 'SetNull', onUpdate: 'Cascade' } };
+const _DEFAULT_CASCADE = { onDelete: 'SetNull', onUpdate: 'Cascade' };
+const _DEFAULTS = { required: false, many: false, embed: false, cascade: null };
 function Relation(theModel, relationOptions = _DEFAULTS) {
     return function (target, key) {
         // Store the promise in metadata immediately
@@ -15,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,11 +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 log = console.log;
+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
@@ -40,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 = '';
             }
@@ -66,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';
@@ -84,12 +96,13 @@ 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}", ${cascadeOpts.join(', ')})\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}", ${cascadeOpts.join(', ')})\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,15 +195,41 @@ datasource db {
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions(trackMeta, dbType);
                 tags.push(...dbSpecificTags);
-                if (modelName === 'category_translation' && key === 'meta_keywords') {
-                    console.log({ requiredString, trackMeta });
+                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${key} ${type_converter_1.TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
+                section += `\t${trackField}\n`;
             }
         }
+        if (model._SUPER_TAGS.length) {
+            section += '\n';
+        }
         for (const superTag of model._SUPER_TAGS) {
             const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
-            section += `\t@@${superTag.tagType}([${superTag.fields.join(', ')}]${mapStr})\n`;
+            const superFields = [];
+            for (const superField of superTag.fields) {
+                const fieldMetadata = modelMetadatas[superField]['metadata'];
+                let pushed = false;
+                if (fieldMetadata.dbOptions && fieldMetadata.dbOptions.mysql && fieldMetadata.dbOptions.mysql.useType) {
+                    switch (fieldMetadata.dbOptions.mysql.useType) {
+                        case 'db.LongText':
+                            superFields.push(`${superField}(length: 255)`);
+                            pushed = true;
+                            break;
+                    }
+                }
+                if (!pushed) {
+                    superFields.push(superField);
+                }
+            }
+            section += `\t@@${superTag.tagType}([${superFields.join(', ')}]${mapStr})\n`;
         }
         section += '}\n';
         return section;
@@ -224,7 +272,7 @@ datasource db {
             for (const model of dbModels) {
                 const modelSection = await SchemaGenerator.generateModelSections(model, configService);
                 template += '\n\n' + modelSection;
-                log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
+                console.log(chalk_1.default.green('[RWS]'), chalk_1.default.blue('Building DB Model'), model.name);
             }
             const [schemaDir, schemaPath] = utils_1.DbUtils.getSchemaDir();
             if (!fs_1.default.existsSync(schemaDir)) {
@@ -234,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;
-            log(chalk_1.default.green('[RWS Init]') + ' prisma schema generated from ', schemaPath);
-            if (!leaveFile) {
-                // fs.unlinkSync(schemaPath);
+            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 (_REMOVE_SCHEMA_FILE) {
+                fs_1.default.unlinkSync(schemaPath);
             }
         }
     }
@@ -255,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,12 +9,30 @@ 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
         if (input == 'Number') {
-            input = 'Int';
+            let numberOverride = false;
+            if (modelType.dbOptions && modelType.dbOptions.mysql) {
+                if (modelType.dbOptions.mysql.useType) {
+                    if (['db.Float'].includes(modelType.dbOptions.mysql.useType)) {
+                        input = 'Float';
+                        numberOverride = true;
+                    }
+                    if (['db.Decimal'].includes(modelType.dbOptions.mysql.useType)) {
+                        input = 'Decimal';
+                        numberOverride = true;
+                    }
+                }
+            }
+            if (!numberOverride) {
+                input = 'Int';
+            }
+        }
+        if (input == 'BigInt') {
+            input = 'BigInt';
         }
         if (input == 'Object') {
             input = 'Json';
@@ -38,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) {
@@ -66,20 +85,25 @@ class TypeConverter {
      * @returns Array of tags to apply to the field
      */
     static processTypeOptions(metadata, dbType) {
-        var _a, _b;
         const tags = [...(metadata.tags || [])];
         // Extract any database-specific options from the metadata
         // and convert them to appropriate Prisma schema tags
         if (metadata.dbOptions) {
             // Handle MySQL-specific options
             if (dbType === 'mysql' && metadata.dbOptions.mysql) {
+                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 : (metadata.dbOptions.mysql?.params?.join(', ') || '');
+                    tag = `@${tagName}(${tagParams})`;
+                }
                 if (metadata.dbOptions.mysql.useText) {
                     tags.push('@db.Text');
                 }
-                else if (metadata.dbOptions.mysql.maxLength) {
-                    tags.push(`@db.VarChar(${metadata.dbOptions.mysql.maxLength})`);
+                if (tag) {
+                    tags.push(tag);
                 }
-                if (metadata.dbOptions.mysql.useUuid && ((_a = metadata.tags) === null || _a === void 0 ? void 0 : _a.includes('id'))) {
+                if (metadata.dbOptions.mysql.useUuid && metadata.tags?.includes('id')) {
                     tags.push('default(uuid())');
                 }
             }
@@ -88,7 +112,7 @@ class TypeConverter {
                 if (metadata.dbOptions.postgres.useText) {
                     tags.push('@db.Text');
                 }
-                if (metadata.dbOptions.postgres.useUuid && ((_b = metadata.tags) === null || _b === void 0 ? void 0 : _b.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;