@rws-framework/db 2.4.6 → 3.0.0

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

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaGenerator = void 0;
+const console_1 = require("@rws-framework/console");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+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;
+/**
+ * Handles Prisma schema generation
+ */
+class SchemaGenerator {
+    /**
+     * Generate the base schema for Prisma
+     * @param dbType The database type
+     * @param dbUrl The database URL
+     * @returns The base schema
+     */
+    static generateBaseSchema(dbType, dbUrl) {
+        process.env = { ...process.env, [this.dbUrlVarName]: dbUrl };
+        return `generator client {
+    provider = "prisma-client-js"
+}
+
+datasource db {
+    provider = "${dbType}"
+    url = env("${this.dbUrlVarName}")
+}`;
+    }
+    /**
+     * Generate model sections for the schema
+     * @param model The model to generate a section for
+     * @param configService The configuration service
+     * @returns The model section
+     */
+    static 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) {
+            section += `\t${utils_1.DbUtils.generateId(dbType, modelMetadatas, false)}\n`;
+        }
+        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) {
+                indexedId = true;
+                requiredString = '';
+            }
+            if (key === 'id' && !indexedId) {
+                continue;
+            }
+            if (annotationType === 'Relation') {
+                const relationMeta = modelMetadata;
+                const relatedModel = relationMeta.relatedTo;
+                const isMany = relationMeta.many;
+                const cascadeOpts = [];
+                if ((_a = relationMeta.cascade) === null || _a === void 0 ? void 0 : _a.onDelete) {
+                    cascadeOpts.push(`onDelete: ${relationMeta.cascade.onDelete}`);
+                }
+                if ((_b = relationMeta.cascade) === null || _b === void 0 ? void 0 : _b.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 relatedModelMetadatas = await _model_1.RWSModel.getModelAnnotations(relatedModel);
+                const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
+                const relatedToField = modelMetadata.relatedToField || 'id';
+                const bindingFieldExists = !!modelMetadatas[relationFieldName];
+                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`;
+                }
+                else {
+                    section += `\t${key} ${relatedModel._collection}${requiredString} @relation("${relationName}", fields: [${relationFieldName}], references: [${relatedToField}], map: "${mapName}", ${cascadeOpts.join(', ')})\n`;
+                    if (!bindingFieldExists) {
+                        const relatedFieldMeta = relatedModelMetadatas[relatedToField];
+                        if (!relatedFieldMeta.metadata.required) {
+                            requiredString = '';
+                        }
+                        let relatedFieldType = type_converter_1.TypeConverter.toConfigCase(relatedFieldMeta.metadata, dbType, true);
+                        if (relatedToField === 'id' && dbType !== 'mongodb') {
+                            relatedFieldType = 'Int';
+                        }
+                        // Add relation field with appropriate type based on database
+                        if (dbType === 'mongodb') {
+                            section += `\t${relationFieldName} String${requiredString} @db.ObjectId\n`;
+                        }
+                        else if (dbType === 'mysql') {
+                            // For MySQL, determine the type based on the related model's ID type
+                            section += `\t${relationFieldName} ${relatedFieldType}${requiredString}\n`;
+                        }
+                        else if (dbType === 'postgresql' || dbType === 'postgres') {
+                            if (relatedFieldType === 'String') {
+                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString} @db.Uuid\n`;
+                            }
+                            else {
+                                section += `\t${relationFieldName} ${relatedFieldType}${requiredString}\n`;
+                            }
+                        }
+                        else {
+                            section += `\t${relationFieldName} String${requiredString}\n`;
+                        }
+                    }
+                }
+                relation_manager_1.RelationManager.completeRelation(relationKey, relationIndex);
+            }
+            else if (annotationType === 'InverseRelation') {
+                const relationMeta = modelMetadata;
+                // Check if we need a custom relation name (if there are multiple relations to the same model)
+                const relatedModelName = relationMeta.inversionModel._collection;
+                // Generate a very short relation name using a counter
+                // Use a consistent key for both sides of the relation to ensure the same name is used
+                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`;
+                relation_manager_1.RelationManager.completeRelation(relationKey, relationIndex, true);
+            }
+            else if (annotationType === 'InverseTimeSeries') {
+                if (dbType === 'mongodb') {
+                    section += `\t${key} String[] @db.ObjectId\n`;
+                }
+                else if (dbType === 'mysql') {
+                    // For MySQL, we need a different approach for arrays
+                    section += `\t${key} Json\n`;
+                }
+                else if (dbType === 'postgresql' || dbType === 'postgres') {
+                    // PostgreSQL supports arrays natively
+                    section += `\t${key} String[]\n`;
+                }
+                else {
+                    section += `\t${key} String[]\n`;
+                }
+            }
+            else if (annotationType === 'TrackType') {
+                const trackMeta = modelMetadata;
+                const tags = trackMeta.tags.map((item) => '@' + item);
+                if (trackMeta.unique) {
+                    const fieldDetail = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
+                    tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
+                }
+                if (trackMeta.isArray || trackMeta.type.name === 'Array') {
+                    requiredString = '';
+                }
+                // 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`;
+            }
+        }
+        for (const superTag of model._SUPER_TAGS) {
+            const mapStr = superTag.map ? `, map: "${superTag.map}"` : '';
+            section += `\t@@${superTag.tagType}([${superTag.fields.join(', ')}]${mapStr})\n`;
+        }
+        section += '}\n';
+        return section;
+    }
+    /**
+     * Install Prisma with the generated schema
+     * @param configService The configuration service
+     * @param dbService The database service
+     * @param leaveFile Whether to leave the schema file after generation
+     */
+    static async installPrisma(configService, dbService, leaveFile = false) {
+        const dbUrl = configService.get('db_url');
+        const dbType = configService.get('db_type') || 'mongodb';
+        let template = this.generateBaseSchema(dbType, dbUrl);
+        const dbModels = configService.get('db_models');
+        if (dbModels) {
+            for (const model of dbModels) {
+                const modelName = model._collection;
+                const modelMetadatas = await _model_1.RWSModel.getModelAnnotations(model);
+                for (const key in modelMetadatas) {
+                    const annotationType = modelMetadatas[key].annotationType;
+                    if (annotationType === 'Relation') {
+                        const relationMeta = modelMetadatas[key].metadata;
+                        const relatedModel = relationMeta.relatedTo;
+                        const relatedModelName = relatedModel._collection;
+                        const relationKey = [modelName, relatedModelName].join('_');
+                        // Add this relation to the map
+                        relation_manager_1.RelationManager.markRelation(relationKey);
+                    }
+                    if (annotationType === 'InverseRelation') {
+                        const relationMeta = modelMetadatas[key].metadata;
+                        const relatedModel = relationMeta.inversionModel;
+                        const relatedModelName = relatedModel._collection;
+                        const relationKey = [relatedModelName, modelName].join('_');
+                        relation_manager_1.RelationManager.markRelation(relationKey, true);
+                    }
+                }
+            }
+            // Now generate the model sections with all relations
+            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);
+            }
+            const [schemaDir, schemaPath] = utils_1.DbUtils.getSchemaDir();
+            if (!fs_1.default.existsSync(schemaDir)) {
+                fs_1.default.mkdirSync(schemaDir);
+            }
+            if (fs_1.default.existsSync(schemaPath)) {
+                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);
+            }
+        }
+    }
+    /**
+     * Push database models to the database
+     * @param configService The configuration service
+     * @param dbService The database service
+     * @param leaveFile Whether to leave the schema file after generation
+     */
+    static async pushDBModels(configService, dbService, leaveFile = false) {
+        process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
+        const [_, schemaPath] = utils_1.DbUtils.getSchemaDir();
+        await console_1.rwsShell.runCommand(`${utils_1.DbUtils.detectInstaller()} prisma db push --schema=${schemaPath}`, process.cwd());
+    }
+}
+exports.SchemaGenerator = SchemaGenerator;
+SchemaGenerator.dbUrlVarName = 'PRISMA_DB_URL';

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

@@ -0,0 +1,22 @@
+import { IDbOpts } from '../../models/interfaces/IDbOpts';
+import { ITrackerMetaOpts } from '../../models/_model';
+import { IIdMetaOpts } from 'src/decorators/IdType';
+/**
+ * Handles type conversion for database schema generation
+ */
+export declare class TypeConverter {
+    /**
+     * Convert a JavaScript type to a Prisma schema type
+     */
+    static toConfigCase(modelType: ITrackerMetaOpts | IIdMetaOpts, dbType?: string, isId?: boolean): string;
+    /**
+     * Process type functions metadata to extract database-specific options
+     * @param metadata The metadata from a type function
+     * @param dbType The database type
+     * @returns Array of tags to apply to the field
+     */
+    static processTypeOptions(metadata: {
+        tags: string[];
+        dbOptions: IDbOpts['dbOptions'];
+    }, dbType: string): string[];
+}

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeConverter = void 0;
+/**
+ * Handles type conversion for database schema generation
+ */
+class TypeConverter {
+    /**
+     * Convert a JavaScript type to a Prisma schema type
+     */
+    static toConfigCase(modelType, dbType = 'mongodb', isId = false) {
+        const type = modelType.type;
+        let input = type.name;
+        // Handle basic types
+        if (input == 'Number') {
+            input = 'Int';
+        }
+        if (input == 'Object') {
+            input = 'Json';
+        }
+        if (input == 'Date') {
+            input = 'DateTime';
+        }
+        if (input == 'Boolean') {
+            // Ensure Boolean is properly handled for all database types
+            input = 'Boolean';
+        }
+        if (input == 'Array') {
+            // Handle arrays differently based on database type
+            if (dbType === 'mysql') {
+                // MySQL doesn't support native arrays, use Json instead
+                input = 'Json';
+            }
+            else {
+                input = 'Json[]';
+            }
+        }
+        const firstChar = input.charAt(0).toUpperCase();
+        const restOfString = input.slice(1);
+        let resultField = firstChar + restOfString;
+        if (isId) {
+            return dbType === 'mongodb' ? 'String' : 'Int';
+        }
+        const trackerModelType = modelType;
+        if (trackerModelType.isArray) {
+            // Handle arrays differently based on database type
+            if (dbType === 'mysql') {
+                // For MySQL, we don't append [] as it doesn't support native arrays
+                // Instead, we'll store arrays as JSON
+                resultField = 'Json';
+            }
+            else if (dbType === 'postgresql' || dbType === 'postgres') {
+                // PostgreSQL supports arrays natively
+                resultField += '[]';
+            }
+            else {
+                resultField += '[]';
+            }
+        }
+        return resultField;
+    }
+    /**
+     * Process type functions metadata to extract database-specific options
+     * @param metadata The metadata from a type function
+     * @param dbType The database type
+     * @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) {
+                if (metadata.dbOptions.mysql.useText) {
+                    tags.push('@db.Text');
+                }
+                else if (metadata.dbOptions.mysql.maxLength) {
+                    tags.push(`@db.VarChar(${metadata.dbOptions.mysql.maxLength})`);
+                }
+                if (metadata.dbOptions.mysql.useUuid && ((_a = metadata.tags) === null || _a === void 0 ? void 0 : _a.includes('id'))) {
+                    tags.push('default(uuid())');
+                }
+            }
+            // Handle PostgreSQL-specific options
+            if ((dbType === 'postgresql' || dbType === 'postgres') && metadata.dbOptions.postgres) {
+                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'))) {
+                    tags.push('@default(uuid())');
+                    tags.push('@db.Uuid');
+                }
+            }
+            // Handle MongoDB-specific options
+            if (dbType === 'mongodb' && metadata.dbOptions.mongodb) {
+                if (metadata.dbOptions.mongodb.customType) {
+                    tags.push(`@db.${metadata.dbOptions.mongodb.customType}`);
+                }
+            }
+        }
+        return tags;
+    }
+}
+exports.TypeConverter = TypeConverter;

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

@@ -0,0 +1,24 @@
+import { IDbConfigParams } from '../../types/DbConfigHandler';
+import { IIdMetaOpts } from '../../decorators/IdType';
+/**
+ * Utility functions for database operations
+ */
+export declare class DbUtils {
+    /**
+     * Get the directory and path for the Prisma schema file
+     */
+    static getSchemaDir(): [string, string];
+    /**
+     * Detect the package installer (yarn or npx)
+     */
+    static detectInstaller(): string;
+    /**
+     * Generate an ID field based on the database type
+     */
+    static generateId(dbType: IDbConfigParams['db_type'], modelMeta: Record<string, {
+        annotationType: string;
+        metadata: IIdMetaOpts;
+    }>, debug?: boolean): string;
+}
+export declare const workspaceRootPath: string;
+export declare const moduleDirPath: string;

package/dist/helper/db/utils.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleDirPath = exports.workspaceRootPath = exports.DbUtils = void 0;
+const console_1 = require("@rws-framework/console");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const type_converter_1 = require("./type-converter");
+const workspaceRoot = console_1.rwsPath.findRootWorkspacePath();
+const moduleDir = path_1.default.resolve(workspaceRoot, 'node_modules', '@rws-framework', 'db');
+/**
+ * Utility functions for database operations
+ */
+class DbUtils {
+    /**
+     * Get the directory and path for the Prisma schema file
+     */
+    static getSchemaDir() {
+        const schemaDir = path_1.default.join(moduleDir, 'prisma');
+        const schemaPath = path_1.default.join(schemaDir, 'schema.prisma');
+        return [schemaDir, schemaPath];
+    }
+    /**
+     * Detect the package installer (yarn or npx)
+     */
+    static detectInstaller() {
+        if (fs_1.default.existsSync(path_1.default.join(workspaceRoot, 'yarn.lock'))) {
+            return 'yarn';
+        }
+        return 'npx';
+    }
+    /**
+     * Generate an ID field based on the database type
+     */
+    static generateId(dbType, modelMeta, debug = false) {
+        var _a, _b, _c, _d;
+        let useUuid = false;
+        let field = 'id';
+        const tags = [];
+        for (const key in modelMeta) {
+            const modelMetadata = modelMeta[key].metadata;
+            const annotationType = modelMeta[key].annotationType;
+            if (key !== 'id') {
+                if (annotationType == 'IdType') {
+                    const dbSpecificTags = type_converter_1.TypeConverter.processTypeOptions({ tags: [], dbOptions: modelMetadata.dbOptions }, dbType);
+                    tags.push(...dbSpecificTags);
+                    if (debug) {
+                        console.log({ modelMetadata: modelMetadata.dbOptions });
+                    }
+                    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;
+        switch (dbType) {
+            case 'mongodb':
+                idString = `${field} String @id @default(auto()) @map("_id") @db.ObjectId`;
+                break;
+            case 'mysql':
+                idString = useUuid
+                    ? `${field} String @id @default(uuid())`
+                    : `${field} Int @id @default(autoincrement())`;
+                break;
+            case 'postgresql':
+            case 'postgres':
+                idString = useUuid
+                    ? `${field} String @id @default(uuid())`
+                    : `${field} Int @id @default(autoincrement())`;
+                break;
+            case 'sqlite':
+                idString = `${field} Int @id @default(autoincrement())`;
+                break;
+        }
+        if (tags.length) {
+            idString += ' ' + tags.join(' ');
+        }
+        if (!idString) {
+            throw new Error(`DB type "${dbType}" is not supported!`);
+        }
+        if (debug) {
+            console.log({ idString, useUuid });
+        }
+        return idString;
+    }
+}
+exports.DbUtils = DbUtils;
+exports.workspaceRootPath = workspaceRoot;
+exports.moduleDirPath = moduleDir;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { DBService } from "./services/DBService";
 import { RWSModel, OpModelType } from "./models/_model";
-import { InverseRelation, Relation, TrackType, InverseTimeSeries, IMetaOpts } from './decorators';
+import { InverseRelation, Relation, TrackType, IdType, InverseTimeSeries, ITrackerMetaOpts, ITrackerOpts } from './decorators';
 import { DbHelper } from './helper/DbHelper';
 import { FieldsHelper } from './helper/FieldsHelper';
 import type { FindByType } from './types/FindParams';
@@ -8,5 +8,5 @@ import type { ITimeSeries } from './types/ITimeSeries';
 import type { IDbConfigHandler, IDbConfigParams } from './types/DbConfigHandler';
 import type { IRWSModel } from './types/IRWSModel';
 import { RWSCollection, IRWSCollectionMeta, IRWSCollectionOpts } from "./decorators/RWSCollection";
-export type { IRWSCollectionMeta, IRWSCollectionOpts, IRWSModel, IMetaOpts, OpModelType, IDbConfigHandler, IDbConfigParams, ITimeSeries, };
-export { RWSModel, RWSCollection, DBService, FindByType, InverseRelation, Relation, TrackType, InverseTimeSeries, DbHelper, FieldsHelper };
+export type { IRWSCollectionMeta, IRWSCollectionOpts, IRWSModel, ITrackerMetaOpts, ITrackerOpts, OpModelType, IDbConfigHandler, IDbConfigParams, ITimeSeries, };
+export { RWSModel, RWSCollection, DBService, FindByType, InverseRelation, Relation, TrackType, InverseTimeSeries, IdType, DbHelper, FieldsHelper };

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldsHelper = exports.DbHelper = exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = exports.DBService = exports.RWSCollection = exports.RWSModel = void 0;
+exports.FieldsHelper = exports.DbHelper = exports.IdType = exports.InverseTimeSeries = exports.TrackType = exports.Relation = exports.InverseRelation = exports.DBService = exports.RWSCollection = exports.RWSModel = void 0;
 const DBService_1 = require("./services/DBService");
 Object.defineProperty(exports, "DBService", { enumerable: true, get: function () { return DBService_1.DBService; } });
 const _model_1 = require("./models/_model");
@@ -10,6 +10,7 @@ const decorators_1 = require("./decorators");
 Object.defineProperty(exports, "InverseRelation", { enumerable: true, get: function () { return decorators_1.InverseRelation; } });
 Object.defineProperty(exports, "Relation", { enumerable: true, get: function () { return decorators_1.Relation; } });
 Object.defineProperty(exports, "TrackType", { enumerable: true, get: function () { return decorators_1.TrackType; } });
+Object.defineProperty(exports, "IdType", { enumerable: true, get: function () { return decorators_1.IdType; } });
 Object.defineProperty(exports, "InverseTimeSeries", { enumerable: true, get: function () { return decorators_1.InverseTimeSeries; } });
 const DbHelper_1 = require("./helper/DbHelper");
 Object.defineProperty(exports, "DbHelper", { enumerable: true, get: function () { return DbHelper_1.DbHelper; } });

package/dist/models/TimeSeriesModel.d.ts

@@ -1,7 +1,7 @@
-import { RWSModel } from './_model';
-export default class TimeSeriesModel<ChildClass> extends RWSModel<TimeSeriesModel<ChildClass>> {
-    value: number;
-    timestamp: Date;
-    params: any;
-    constructor(data?: any);
-}
+import { RWSModel } from './_model';
+export default class TimeSeriesModel<ChildClass> extends RWSModel<TimeSeriesModel<ChildClass>> {
+    value: number;
+    timestamp: Date;
+    params: any;
+    constructor(data?: any);
+}

package/dist/models/TimeSeriesModel.js

@@ -1,33 +1,33 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const _model_1 = require("./_model");
-class TimeSeriesModel extends _model_1.RWSModel {
-    constructor(data) {
-        super(data);
-        if (!this.timestamp) {
-            this.timestamp = new Date();
-        }
-    }
-}
-exports.default = TimeSeriesModel;
-__decorate([
-    (0, _model_1.TrackType)(Number),
-    __metadata("design:type", Number)
-], TimeSeriesModel.prototype, "value", void 0);
-__decorate([
-    (0, _model_1.TrackType)(Date),
-    __metadata("design:type", Date)
-], TimeSeriesModel.prototype, "timestamp", void 0);
-__decorate([
-    (0, _model_1.TrackType)(Object),
-    __metadata("design:type", Object)
-], TimeSeriesModel.prototype, "params", void 0);
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _model_1 = require("./_model");
+class TimeSeriesModel extends _model_1.RWSModel {
+    constructor(data) {
+        super(data);
+        if (!this.timestamp) {
+            this.timestamp = new Date();
+        }
+    }
+}
+exports.default = TimeSeriesModel;
+__decorate([
+    (0, _model_1.TrackType)(Number),
+    __metadata("design:type", Number)
+], TimeSeriesModel.prototype, "value", void 0);
+__decorate([
+    (0, _model_1.TrackType)(Date),
+    __metadata("design:type", Date)
+], TimeSeriesModel.prototype, "timestamp", void 0);
+__decorate([
+    (0, _model_1.TrackType)(Object),
+    __metadata("design:type", Object)
+], TimeSeriesModel.prototype, "params", void 0);

package/dist/models/_model.d.ts

@@ -1,6 +1,6 @@
 /**
  * @deprecated This file is deprecated. Import from 'models' directory instead.
  */
-import { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, RWSModel, TrackType, IMetaOpts } from './index';
+import { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, RWSModel, TrackType, ITrackerMetaOpts } from './index';
 export { RWSModel, TrackType };
-export type { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, IMetaOpts };
+export type { IModel, IRWSModelServices, OpModelType, RelationBindType, RelOneMetaType, RelManyMetaType, ITrackerMetaOpts };

package/dist/models/core/RWSModel.d.ts

@@ -3,12 +3,15 @@ import { IRWSModelServices } from '../interfaces/IRWSModelServices';
 import { OpModelType } from '../interfaces/OpModelType';
 import { FindByType, IPaginationParams } from '../../types/FindParams';
 import { DBService } from '../../services/DBService';
+import { ISuperTagData } from '../../decorators/RWSCollection';
 declare class RWSModel<T> implements IModel {
     static services: IRWSModelServices;
     [key: string]: any;
     id: string | number;
     static _collection: string;
     static _RELATIONS: {};
+    static _NO_ID: boolean;
+    static _SUPER_TAGS: ISuperTagData[];
     static _BANNED_KEYS: string[];
     static allModels: OpModelType<any>[];
     static _CUT_KEYS: string[];
@@ -58,7 +61,7 @@ declare class RWSModel<T> implements IModel {
     static create<T extends RWSModel<T>>(this: new () => T, data: any): Promise<T>;
     static loadModels(): OpModelType<any>[];
     loadModels(): OpModelType<any>[];
-    private checkRelEnabled;
+    private checkRelDisabled;
     static setServices(services: IRWSModelServices): void;
     getDb(): DBService;
     static getDb(): DBService;