taon 21.0.52 → 21.0.54

package/lib-prod/base-classes/base-custom-repository.js

@@ -0,0 +1,9 @@
+import { TaonRepository } from '../decorators/classes/repository-decorator';
+import { TaonBaseInjector } from './base-injector';
+//#endregion
+let TaonBaseCustomRepository = class TaonBaseCustomRepository extends TaonBaseInjector {
+};
+TaonBaseCustomRepository = __decorate([
+    TaonRepository({ className: 'TaonBaseCustomRepository' })
+], TaonBaseCustomRepository);
+export { TaonBaseCustomRepository };

package/lib-prod/base-classes/{base-electron-service.ts → base-electron-service.js}

@@ -2,35 +2,26 @@
 // //#region imports
 // import * as childProcess from 'child_process';
 // import * as fs from 'fs';
-
 // import { Injectable } from '@angular/core';
 // import { ipcRenderer, webFrame } from 'electron';
 // import { UtilsOs } from 'tnp-core/src';
 // //#endregion
-
 // // If you import a module but never use any of the imported values other than as TypeScript types,
 // // the resulting javascript file will look as if you never imported the module at all.
-
 // @Injectable({
 //   providedIn: 'root',
 // })
 // export class TaonBaseElectronService {
 //   ipcRenderer!: typeof ipcRenderer;
-
 //   webFrame!: typeof webFrame;
-
 //   childProcess!: typeof childProcess;
-
 //   fs!: typeof fs;
-
 //   constructor() {
 //     // Conditional imports
 //     if (UtilsOs.isElectron) {
 //       this.ipcRenderer = (window as any).require('electron').ipcRenderer;
 //       this.webFrame = (window as any).require('electron').webFrame;
-
 //       this.fs = (window as any).require('fs');
-
 //       this.childProcess = (window as any).require('child_process');
 //       this.childProcess.exec('node -v', (error, stdout, stderr) => {
 //         if (error) {
@@ -43,7 +34,6 @@
 //         }
 //         console.log(`stdout:\n${stdout}`);
 //       });
-
 //       // Notes :
 //       // * A NodeJS's dependency imported with 'window.require' MUST BE present in `dependencies` of both `app/package.json`
 //       // and `package.json (root folder)` in order to make it work here in Electron's Renderer process (src folder)
@@ -51,10 +41,9 @@
 //       // * A NodeJS's dependency imported with TS module import (ex: import { Dropbox } from 'dropbox') CAN only be present
 //       // in `dependencies` of `package.json (root folder)` because it is loaded during build phase and does not need to be
 //       // in the final bundle. Reminder : only if not used in Electron's Main process (app folder)
-
 //       // If you want to use a NodeJS 3rd party deps in Renderer process,
 //       // ipcRenderer.invoke can serve many common use cases.
 //       // https://www.electronjs.org/docs/latest/api/ipc-renderer#ipcrendererinvokechannel-args
 //     }
 //   }
-// }
+// }

package/lib-prod/base-classes/base-entity.js

@@ -0,0 +1,22 @@
+import { Entity } from 'taon-typeorm/lib-prod'; // @websql
+import { TaonBaseClass } from './base-class';
+//#region @websql
+let TaonBaseEntity = class TaonBaseEntity extends TaonBaseClass {
+    /**
+     * simple check if relation is ok
+     */
+    relation(relationName) {
+        return relationName;
+    }
+    /**
+     * simple check if relation is ok
+     */
+    relations(relationNames) {
+        return relationNames;
+    }
+};
+TaonBaseEntity = __decorate([
+    Entity()
+    //#endregion
+], TaonBaseEntity);
+export { TaonBaseEntity };

package/lib-prod/base-classes/base-file-upload.middleware.js

@@ -0,0 +1,75 @@
+//#region imports
+import * as crypto from 'crypto';
+import * as multer from 'multer';
+import { crossPlatformPath, fse, path } from 'tnp-core/lib-prod';
+import { TaonMiddleware } from '../decorators/classes/middleware-decorator';
+import { TaonBaseMiddleware, } from './base-middleware';
+//#endregion
+/**
+ * Configurable file upload middleware (multer based)
+ */
+let TaonBaseFileUploadMiddleware = class TaonBaseFileUploadMiddleware extends TaonBaseMiddleware {
+    async interceptServerMethod({ req, res, next }, { methodName, expressPath }) {
+        return this.middleware()(req, res, next);
+    }
+    //#region upload Dir
+    uploadDir() {
+        return crossPlatformPath([this.ctx.cwd, 'uploaded-files']);
+    }
+    //#endregion
+    //#region storage
+    storage() {
+        //#region @backendFunc
+        const uploadDir = this.uploadDir();
+        if (!fse.existsSync(uploadDir)) {
+            try {
+                fse.mkdirSync(uploadDir, { recursive: true });
+            }
+            catch (error) { }
+        }
+        return multer.diskStorage({
+            destination: (_req, _file, cb) => cb(null, uploadDir),
+            filename: (_req, file, cb) => {
+                const ext = path.extname(file.originalname).toLowerCase();
+                const base = path
+                    .basename(file.originalname, ext)
+                    .replace(/[^\w.-]/g, '_');
+                const uniq = `${Date.now()}-${crypto.randomBytes(6).toString('hex')}`;
+                const filenameToProcess = `${base}-${uniq}${ext}`;
+                cb(null, filenameToProcess);
+            },
+        });
+        //#endregion
+    }
+    //#endregion
+    //#region upload
+    upload() {
+        //#region @backendFunc
+        return multer({
+            storage: this.storage(),
+            limits: { fileSize: 1024 * 1024 * 1024 }, // 1 GiB cap; tweak as needed
+            // TODO implement file filter if needed
+            // fileFilter: (_req, file, cb) => {
+            //   // accept only .zip by filename extension
+            //   if (path.extname(file.originalname).toLowerCase() !== '.zip') {
+            //     return cb(new Error('Only .zip files are allowed'));
+            //   }
+            //   cb(null, true);
+            // },
+        });
+        //#endregion
+    }
+    //#endregion
+    //#region middleware
+    middleware() {
+        //#region @backendFunc
+        return this.upload().any();
+        //#endregion
+    }
+};
+TaonBaseFileUploadMiddleware = __decorate([
+    TaonMiddleware({
+        className: 'TaonBaseFileUploadMiddleware',
+    })
+], TaonBaseFileUploadMiddleware);
+export { TaonBaseFileUploadMiddleware };

package/lib-prod/base-classes/base-injector.js

@@ -0,0 +1,184 @@
+import { ClassHelpers__NS__getName } from '../helpers/class-helpers';
+import { Symbols__NS__ctxInClassOrClassObj } from '../symbols';
+//#endregion
+export class TaonBaseInjector {
+    //#endregion
+    //#region class initialization hook
+    /**
+     * class initialization hook
+     * taon after class instace creation
+     */
+    async _() { }
+    //#endregion
+    //#region context
+    /**
+     * @deprecated use ctx instead
+     * Current endpoint context
+     */
+    get __endpoint_context__() {
+        return this[Symbols__NS__ctxInClassOrClassObj];
+    }
+    /**
+     * get  current endpoint context
+     */
+    get ctx() {
+        return this.__endpoint_context__;
+    }
+    //#endregion
+    //#region inject
+    //#region inject / repo for entity
+    /**
+     * inject crud repo for entity
+     */
+    injectRepo(entityForCrud) {
+        const repoProxy = this.__inject(void 0, {
+            localInstance: true,
+            resolveClassFromContext: 'TaonBaseRepository',
+            locaInstanceConstructorArgs: [() => entityForCrud],
+        });
+        return repoProxy;
+    }
+    //#endregion
+    //#region inject / custom repository
+    injectCustomRepository(cutomRepositoryClass) {
+        const repoProxy = this.__inject(cutomRepositoryClass, {
+            localInstance: true,
+            locaInstanceConstructorArgs: [
+                () => {
+                    const classToProcess = this.ctx.allClassesInstances[ClassHelpers__NS__getName(cutomRepositoryClass)];
+                    return classToProcess.entityClassResolveFn();
+                },
+            ],
+        });
+        return repoProxy;
+    }
+    //#endregion
+    //#region inject / custom repo
+    /**
+     * aliast to this.injectRepository()
+     */
+    injectCustomRepo(cutomRepositoryClass) {
+        const repoProxy = this.injectCustomRepository(cutomRepositoryClass);
+        return repoProxy;
+    }
+    //#endregion
+    //#region inject / controller
+    /**
+     * example usage:
+     * ...
+     * exampleController = this.injectController(ExampleController);
+     * ...
+     */
+    injectController(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    //#endregion
+    //#region inject / ctrl
+    /**
+     * example usage:
+     * ...
+     * exampleSubscriber = this.injectSubscriber(ExampleSubscriber)
+     * ...
+     */
+    injectSubscriber(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    //#endregion
+    //#region inject / ctrl
+    /**
+     * aliast to .injectController()
+     */
+    injectCtrl(ctor) {
+        return this.injectController(ctor);
+    }
+    //#endregion
+    //#region inject / global provider
+    /**
+     * inject middleware for context
+     */
+    injectMiddleware(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    //#endregion
+    //#region inject / context provider
+    /**
+     * inject provider for context
+     */
+    injectProvider(ctor) {
+        return this.__inject(ctor, { localInstance: false });
+    }
+    //#endregion
+    //#region inject / __ inject
+    /**
+     * Inject: Controllers, Providers, Repositories, Services, etc.
+     * TODO  addd nest js injecting
+     */
+    __inject(ctor, options) {
+        if (!options) {
+            options = {};
+        }
+        const contextClassInstance = this;
+        return new Proxy({}, {
+            get: (__, propName) => {
+                const contextFromClass = ctor && ctor[Symbols__NS__ctxInClassOrClassObj];
+                const resultContext = contextFromClass
+                    ? contextFromClass
+                    : this.__endpoint_context__;
+                if (options.resolveClassFromContext) {
+                    const resolvedClass = resultContext.getClassFunByClassName(options.resolveClassFromContext);
+                    ctor = resolvedClass;
+                }
+                if (resultContext) {
+                    var instance = resultContext.inject(ctor, {
+                        ...options,
+                        contextClassInstance,
+                        parentInstanceThatWillGetInjectedStuff: this,
+                    });
+                    if (!instance) {
+                        throw new Error(`Not able to inject "${ClassHelpers__NS__getName(ctor) || ctor.name}" inside ` +
+                            `property "${propName?.toString()}" on  class "${ClassHelpers__NS__getName(this)}".
+
+              Please add "${ClassHelpers__NS__getName(ctor) || ctor.name}" to (entites or contorllers or providers or repositories or middlewares)
+
+              `);
+                    }
+                    const result = typeof instance[propName] === 'function'
+                        ? instance[propName].bind(instance)
+                        : instance[propName];
+                    // console.log(`Accessing injected "${propName?.toString()}" from "${ClassHelpers__NS__getName(ctor) || ctor.name}"`,result)
+                    return result;
+                }
+                /* */
+                /* */
+            },
+            set: (__, propName, value) => {
+                const contextFromClass = ctor && ctor[Symbols__NS__ctxInClassOrClassObj];
+                const resultContext = contextFromClass
+                    ? contextFromClass
+                    : this.__endpoint_context__;
+                if (options.resolveClassFromContext) {
+                    const resolvedClass = resultContext.getClassFunByClassName(options.resolveClassFromContext);
+                    ctor = resolvedClass;
+                }
+                if (resultContext) {
+                    var instance = resultContext.inject(ctor, {
+                        ...options,
+                        contextClassInstance,
+                        parentInstanceThatWillGetInjectedStuff: this,
+                    });
+                    if (!instance) {
+                        const classNameNotResolved = ClassHelpers__NS__getName(ctor) || ctor.name;
+                        throw new Error(`Not able to inject "${classNameNotResolved}" inside ` +
+                            `property "${propName?.toString()}" on  class "${ClassHelpers__NS__getName(this)}".
+
+              Please add "${ClassHelpers__NS__getName(ctor) || ctor.name}" to (entites or contorllers or providers or repositories or middlewares)
+
+              `);
+                    }
+                    instance[propName] = value;
+                }
+                return true;
+            },
+        });
+    }
+}

package/lib-prod/base-classes/base-middleware.js

@@ -0,0 +1,9 @@
+import { TaonBaseInjector } from './base-injector';
+//#endregion
+/**
+ * TODO
+ * - global provider available in all contexts
+ * - provider available in own context
+ */
+export class TaonBaseMiddleware extends TaonBaseInjector {
+}

package/lib-prod/base-classes/base-migration.js

@@ -0,0 +1,20 @@
+import { ___NS__startCase } from 'tnp-core/lib-prod';
+import { ClassHelpers__NS__getName } from '../helpers/class-helpers';
+import { TaonBaseInjector } from './base-injector';
+export class TaonBaseMigration extends TaonBaseInjector {
+    /**
+     * by default is READY to run
+     */
+    isReadyToRun() {
+        return true;
+    }
+    getDescription() {
+        return ___NS__startCase(ClassHelpers__NS__getName(this));
+    }
+    async up(queryRunner) {
+        console.log(`[TaonBaseMigration] Running migration UP "${ClassHelpers__NS__getName(this)}"`);
+    }
+    async down(queryRunner) {
+        console.log(`[TaonBaseMigration] Running migration DOWN "${ClassHelpers__NS__getName(this)}"`);
+    }
+}

package/lib-prod/base-classes/{base-provider.ts → base-provider.js}

@@ -1,8 +1,8 @@
 import { TaonBaseInjector } from './base-injector';
-
 /**
  * TODO
  * - global provider available in all contexts
  * - provider available in own context
  */
-export class TaonBaseProvider extends TaonBaseInjector {}
+export class TaonBaseProvider extends TaonBaseInjector {
+}