mongodb-dynamic-api 1.1.0

package/src/dynamic-api.module.js

@@ -0,0 +1,101 @@
+"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 DynamicApiModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicApiModule = void 0;
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const lodash_1 = require("lodash");
+const decorators_1 = require("./decorators");
+const modules_1 = require("./modules");
+let DynamicApiModule = DynamicApiModule_1 = class DynamicApiModule {
+    static forRoot(uri) {
+        if (!uri) {
+            throw new Error('You must provide a valid mongodb uri in the forRoot method to use MongoDB Dynamic API');
+        }
+        return {
+            module: DynamicApiModule_1,
+            imports: [
+                mongoose_1.MongooseModule.forRoot(uri, { connectionName: DynamicApiModule_1.connectionName }),
+            ],
+        };
+    }
+    static forFeature({ entity, controllerOptions: { path, apiTag, version: controllerVersion, validationPipeOptions: controllerValidationPipeOptions, }, routes = [], }) {
+        const { indexes, hooks } = Reflect.getOwnMetadata(decorators_1.DYNAMIC_API_SCHEMA_OPTIONS_METADATA, entity) ?? {};
+        const schema = mongoose_1.SchemaFactory.createForClass(entity);
+        schema.set('timestamps', true);
+        if (indexes) {
+            indexes.forEach(({ fields, options }) => {
+                schema.index(fields, options);
+            });
+        }
+        if (hooks?.length) {
+            hooks.forEach(({ type, method, callback, options }) => {
+                schema[method](type, { document: true, query: true, ...options }, callback);
+            });
+        }
+        const databaseModule = mongoose_1.MongooseModule.forFeature([{ name: entity.name, schema }], DynamicApiModule_1.connectionName);
+        if (!routes.length) {
+            const contentName = (0, lodash_1.lowerCase)(entity.name);
+            routes = [
+                { type: 'GetMany', description: `Get many ${contentName}` },
+                { type: 'GetOne', description: `Get one ${contentName} by id` },
+                { type: 'CreateMany', description: `Create many ${contentName}` },
+                { type: 'CreateOne', description: `Create one ${contentName}` },
+                { type: 'ReplaceOne', description: `Replace one ${contentName}` },
+                { type: 'UpdateOne', description: `Update one ${contentName}` },
+                { type: 'DuplicateOne', description: `Duplicate one ${contentName}` },
+                { type: 'DeleteOne', description: `Delete one ${contentName}` },
+            ];
+        }
+        return {
+            module: DynamicApiModule_1,
+            imports: [
+                ...routes
+                    .map(({ type, description, dTOs, version: routeVersion, validationPipeOptions: routeValidationPipeOptions, }) => {
+                    let module;
+                    switch (type) {
+                        case 'CreateMany':
+                            module = modules_1.CreateManyModule;
+                            break;
+                        case 'CreateOne':
+                            module = modules_1.CreateOneModule;
+                            break;
+                        case 'DeleteOne':
+                            module = modules_1.DeleteOneModule;
+                            break;
+                        case 'DuplicateOne':
+                            module = modules_1.DuplicateOneModule;
+                            break;
+                        case 'GetMany':
+                            module = modules_1.GetManyModule;
+                            break;
+                        case 'GetOne':
+                            module = modules_1.GetOneModule;
+                            break;
+                        case 'ReplaceOne':
+                            module = modules_1.ReplaceOneModule;
+                            break;
+                        case 'UpdateOne':
+                            module = modules_1.UpdateOneModule;
+                            break;
+                        default:
+                            throw new Error(`Route for ${type} is not implemented`);
+                    }
+                    return module.forFeature(databaseModule, entity, { path, apiTag }, { description, dTOs }, routeVersion ?? controllerVersion, routeValidationPipeOptions ?? controllerValidationPipeOptions);
+                })
+                    .filter((module) => module),
+            ],
+        };
+    }
+};
+exports.DynamicApiModule = DynamicApiModule;
+DynamicApiModule.connectionName = 'dynamic-api-connection';
+exports.DynamicApiModule = DynamicApiModule = DynamicApiModule_1 = __decorate([
+    (0, common_1.Module)({})
+], DynamicApiModule);

package/src/helpers/config.helper.d.ts

@@ -0,0 +1,61 @@
+import { INestApplication, ValidationPipeOptions, VersioningOptions } from '@nestjs/common';
+import { SwaggerDocumentOptions } from '@nestjs/swagger';
+import { ExternalDocumentationObject, ParameterObject, SecuritySchemeObject, ServerVariableObject } from '@nestjs/swagger/dist/interfaces/open-api-spec.interface';
+type DynamicAPISwaggerExtraConfig = {
+    termsOfService?: string;
+    contact?: {
+        name: string;
+        url: string;
+        email: string;
+    };
+    license?: {
+        name: string;
+        url: string;
+    };
+    servers?: {
+        url: string;
+        description?: string;
+        variables?: Record<string, ServerVariableObject>;
+    }[];
+    externalDocs?: {
+        description: string;
+        url: string;
+    };
+    basePath?: string;
+    tags?: {
+        name: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+    }[];
+    extensions?: {
+        [key: string]: any;
+    };
+    security?: {
+        [key: string]: SecuritySchemeObject;
+    };
+    globalParameters?: ParameterObject[];
+    securityRequirements?: {
+        [key: string]: string[];
+    };
+    bearerAuth?: SecuritySchemeObject;
+    oAuth2?: SecuritySchemeObject;
+    apiKey?: SecuritySchemeObject;
+    basicAuth?: SecuritySchemeObject;
+    cookieAuth?: {
+        cookieName: string;
+        options: SecuritySchemeObject;
+        securityName: string;
+    };
+};
+type DynamicAPISwaggerOptions = {
+    title?: string;
+    description?: string;
+    version?: string;
+    path?: string;
+    swaggerConfig?: DynamicAPISwaggerExtraConfig;
+    swaggerOptions?: SwaggerDocumentOptions;
+};
+declare function enableDynamicAPISwagger(app: INestApplication, options?: DynamicAPISwaggerOptions): void;
+declare function enableDynamicAPIVersioning(app: INestApplication, options?: VersioningOptions): void;
+declare function enableDynamicAPIValidation(app: INestApplication, options?: ValidationPipeOptions): void;
+export { enableDynamicAPISwagger, enableDynamicAPIVersioning, enableDynamicAPIValidation, DynamicAPISwaggerOptions, DynamicAPISwaggerExtraConfig, };

package/src/helpers/config.helper.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableDynamicAPIValidation = exports.enableDynamicAPIVersioning = exports.enableDynamicAPISwagger = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const version_json_1 = require("../version.json");
+function buildExtraConfig(config, swaggerConfig) {
+    Object.keys(swaggerConfig).forEach((key) => {
+        const value = swaggerConfig[key];
+        switch (key) {
+            case 'termsOfService':
+                config.setTermsOfService(value);
+                break;
+            case 'contact':
+                config.setContact(value.name, value.url, value.email);
+                break;
+            case 'license':
+                config.setLicense(value.name, value.url);
+                break;
+            case 'servers':
+                value.forEach((server) => {
+                    config.addServer(server.url, server.description, server.variables);
+                });
+                break;
+            case 'externalDocs':
+                config.setExternalDoc(value.description, value.url);
+                break;
+            case 'basePath':
+                config.setBasePath(value);
+                break;
+            case 'tags':
+                value.forEach((tag) => {
+                    config.addTag(tag.name, tag.description, tag.externalDocs);
+                });
+                break;
+            case 'extensions':
+                Object.keys(value).forEach((extensionKey) => {
+                    config.addExtension(extensionKey, value[extensionKey]);
+                });
+                break;
+            case 'security':
+                Object.keys(value).forEach((securityKey) => {
+                    config.addSecurity(securityKey, value[securityKey]);
+                });
+                break;
+            case 'globalParameters':
+                config.addGlobalParameters(...value);
+                break;
+            case 'securityRequirements':
+                Object.keys(value).forEach((securityKey) => {
+                    config.addSecurityRequirements(securityKey, value[securityKey]);
+                });
+                break;
+            case 'bearerAuth':
+                config.addBearerAuth(value);
+                break;
+            case 'oAuth2':
+                config.addOAuth2(value);
+                break;
+            case 'apiKey':
+                config.addApiKey(value);
+                break;
+            case 'basicAuth':
+                config.addBasicAuth(value);
+                break;
+            case 'cookieAuth':
+                config.addCookieAuth(value.cookieName, value.options, value.securityName);
+                break;
+            default:
+                break;
+        }
+    });
+}
+function enableDynamicAPISwagger(app, options = {}) {
+    const { title = 'MongoDB Dynamic API', description = 'Auto generated CRUD for MongoDB', version = version_json_1.default?.version?.split('-beta')[0], path = '/openapi', swaggerConfig, swaggerOptions, } = options ?? {};
+    const config = new swagger_1.DocumentBuilder()
+        .setTitle(title)
+        .setDescription(description)
+        .setVersion(version);
+    buildExtraConfig(config, swaggerConfig ?? {});
+    const document = swagger_1.SwaggerModule.createDocument(app, config.build(), swaggerOptions);
+    swagger_1.SwaggerModule.setup(path, app, document);
+}
+exports.enableDynamicAPISwagger = enableDynamicAPISwagger;
+function enableDynamicAPIVersioning(app, options) {
+    app.enableVersioning({
+        type: common_1.VersioningType.URI,
+        ...options,
+    });
+}
+exports.enableDynamicAPIVersioning = enableDynamicAPIVersioning;
+function enableDynamicAPIValidation(app, options = {}) {
+    app.useGlobalPipes(new common_1.ValidationPipe(options));
+}
+exports.enableDynamicAPIValidation = enableDynamicAPIValidation;

package/src/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './config.helper';
+export * from './route-decorators.helper';

package/src/helpers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config.helper"), exports);
+__exportStar(require("./route-decorators.helper"), exports);

package/src/helpers/route-decorators.helper.d.ts

@@ -0,0 +1,4 @@
+import { RouteDecoratorsBuilder } from '../builders';
+import { BaseEntity } from '../models';
+declare function RouteDecoratorsHelper<Entity extends BaseEntity>(routeDecorators: RouteDecoratorsBuilder<Entity>): <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void;
+export { RouteDecoratorsHelper };

package/src/helpers/route-decorators.helper.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteDecoratorsHelper = void 0;
+const common_1 = require("@nestjs/common");
+function RouteDecoratorsHelper(routeDecorators) {
+    return (0, common_1.applyDecorators)(...routeDecorators.build());
+}
+exports.RouteDecoratorsHelper = RouteDecoratorsHelper;

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from './builders';
+export * from './decorators';
+export * from './dtos';
+export * from './helpers';
+export * from './interfaces';
+export * from './mixins';
+export * from './models';
+export * from './modules';
+export * from './services';
+export * from './dynamic-api.module';

package/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./builders"), exports);
+__exportStar(require("./decorators"), exports);
+__exportStar(require("./dtos"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./mixins"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./modules"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./dynamic-api.module"), exports);

package/src/interfaces/dynamic-api-options.interface.d.ts

@@ -0,0 +1,15 @@
+import { Type, ValidationPipeOptions } from '@nestjs/common';
+import { BaseEntity } from '../models';
+import { RouteConfig } from './route-config.interface';
+interface ControllerOptions {
+    path: string;
+    apiTag?: string;
+    version?: string;
+    validationPipeOptions?: ValidationPipeOptions;
+}
+interface DynamicApiOptions<Entity extends BaseEntity> {
+    entity: Type<Entity>;
+    controllerOptions: ControllerOptions;
+    routes?: RouteConfig<Entity>[];
+}
+export { DynamicApiOptions, ControllerOptions };

package/src/interfaces/dynamic-api-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/dynamic-api-schema-options.interface.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { IndexDefinition, IndexOptions } from 'mongoose';
+type HookEvent = 'find' | 'findOne' | 'save' | 'findOneAndUpdate' | 'findOneAndReplace' | 'deleteOne';
+type SchemaHook = {
+    type: HookEvent;
+    method: 'pre' | 'post';
+    callback: (...args: any[]) => void;
+    options?: {
+        document?: boolean;
+        query?: boolean;
+    };
+};
+interface DynamicAPISchemaOptionsInterface {
+    indexes?: {
+        fields: IndexDefinition;
+        options?: IndexOptions;
+    }[];
+    hooks?: SchemaHook[];
+}
+export type { SchemaHook, DynamicAPISchemaOptionsInterface };

package/src/interfaces/dynamic-api-schema-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/entity-mappers.interface.d.ts

@@ -0,0 +1,8 @@
+import { BaseEntity } from '../models';
+interface BodyToPartialEntityMapper {
+    toEntity?: <Entity extends BaseEntity, Body>(body: Body) => Promise<Partial<Entity>>;
+}
+interface EntityToPresenterMapper {
+    fromEntity?: <Entity extends BaseEntity, Presenter>(entity: Entity) => Promise<Presenter>;
+}
+export type { BodyToPartialEntityMapper, EntityToPresenterMapper };

package/src/interfaces/entity-mappers.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from './entity-mappers.interface';
+export * from './dynamic-api-options.interface';
+export * from './dynamic-api-schema-options.interface';
+export * from './maybe-promise.type';
+export * from './route-config.interface';
+export * from './service-provider.interface';

package/src/interfaces/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entity-mappers.interface"), exports);
+__exportStar(require("./dynamic-api-options.interface"), exports);
+__exportStar(require("./dynamic-api-schema-options.interface"), exports);
+__exportStar(require("./maybe-promise.type"), exports);
+__exportStar(require("./route-config.interface"), exports);
+__exportStar(require("./service-provider.interface"), exports);

package/src/interfaces/maybe-promise.type.d.ts

@@ -0,0 +1,2 @@
+type MaybePromise<T> = T | Promise<T>;
+export type { MaybePromise };

package/src/interfaces/maybe-promise.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/route-config.interface.d.ts

@@ -0,0 +1,17 @@
+import { Type, ValidationPipeOptions } from '@nestjs/common';
+import { BaseEntity } from '../models';
+type RouteType = 'GetMany' | 'GetOne' | 'CreateOne' | 'CreateMany' | 'UpdateOne' | 'ReplaceOne' | 'DeleteOne' | 'DuplicateOne';
+type DTOsBundle = {
+    query?: Type;
+    param?: Type;
+    body?: Type;
+    presenter?: Type;
+};
+interface RouteConfig<Entity extends BaseEntity> {
+    type: RouteType;
+    description?: string;
+    version?: string;
+    dTOs?: DTOsBundle;
+    validationPipeOptions?: ValidationPipeOptions;
+}
+export { DTOsBundle, RouteType, RouteConfig };

package/src/interfaces/route-config.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/interfaces/service-provider.interface.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+interface ServiceProvider {
+    provide: string;
+    useClass: Type;
+}
+export type { ServiceProvider };

package/src/interfaces/service-provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/mixins/entity-body.mixin.d.ts

@@ -0,0 +1,16 @@
+import { Type } from '@nestjs/common';
+import { BaseEntity } from '../models';
+declare const baseEntityKeysToExclude: <Entity extends BaseEntity>() => (keyof Entity)[];
+declare function EntityBodyMixin<Entity extends BaseEntity>(entity: Type<Entity>, update?: boolean, additionalKeysToExclude?: (keyof Entity)[]): {
+    new (...args: any[]): {};
+    apply(this: Function, thisArg: any, argArray?: any): any;
+    call(this: Function, thisArg: any, ...argArray: any[]): any;
+    bind(this: Function, thisArg: any, ...argArray: any[]): any;
+    toString(): string;
+    readonly length: number;
+    arguments: any;
+    caller: Function;
+    readonly name: string;
+    [Symbol.hasInstance](value: any): boolean;
+};
+export { baseEntityKeysToExclude, EntityBodyMixin };

package/src/mixins/entity-body.mixin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityBodyMixin = exports.baseEntityKeysToExclude = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const baseEntityKeysToExclude = () => [
+    'id',
+    'createdAt',
+    'updatedAt',
+    'deletedAt',
+    'isDeleted',
+    '_id',
+    '__v',
+];
+exports.baseEntityKeysToExclude = baseEntityKeysToExclude;
+function EntityBodyMixin(entity, update = false, additionalKeysToExclude) {
+    const keysToExclude = [
+        ...baseEntityKeysToExclude(),
+        ...(additionalKeysToExclude ?? []),
+    ];
+    class EntityBody extends (0, swagger_1.OmitType)(entity, keysToExclude) {
+    }
+    return update ? (0, swagger_1.PartialType)(EntityBody) : EntityBody;
+}
+exports.EntityBodyMixin = EntityBodyMixin;

package/src/mixins/entity-presenter.mixin.d.ts

@@ -0,0 +1,15 @@
+import { Type } from '@nestjs/common';
+import { BaseEntity } from '../models';
+declare function EntityPresenterMixin<Entity extends BaseEntity>(entity: Type<Entity>, keysToExclude?: (keyof Entity)[]): {
+    new (...args: any[]): {};
+    apply(this: Function, thisArg: any, argArray?: any): any;
+    call(this: Function, thisArg: any, ...argArray: any[]): any;
+    bind(this: Function, thisArg: any, ...argArray: any[]): any;
+    toString(): string;
+    readonly length: number;
+    arguments: any;
+    caller: Function;
+    readonly name: string;
+    [Symbol.hasInstance](value: any): boolean;
+};
+export { EntityPresenterMixin };

package/src/mixins/entity-presenter.mixin.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityPresenterMixin = void 0;
+const swagger_1 = require("@nestjs/swagger");
+function EntityPresenterMixin(entity, keysToExclude) {
+    class EntityPresenter extends (keysToExclude ? (0, swagger_1.OmitType)(entity, keysToExclude) : entity) {
+    }
+    return EntityPresenter;
+}
+exports.EntityPresenterMixin = EntityPresenterMixin;

package/src/mixins/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entity-body.mixin';
+export * from './entity-presenter.mixin';

package/src/mixins/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./entity-body.mixin"), exports);
+__exportStar(require("./entity-presenter.mixin"), exports);

package/src/models/base-entity.model.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { ObjectId } from 'mongoose';
+export declare class BaseEntity {
+    _id: ObjectId;
+    __v: number;
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+}