not-node 6.5.27 → 6.5.29

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "not-node",
-	"version": "6.5.27",
+	"version": "6.5.29",
 	"description": "node complimentary part for client side notFramework.",
 	"main": "index.js",
 	"scripts": {

package/src/init/lib/app.js

@@ -5,6 +5,8 @@ const logger = require("not-log");
 const log = logger(module, "not-node//init//app");
 const { notErrorReporter } = require("not-error/src/index.cjs");
 
+const notAppPostponedFieldsRegistrator = require("../../manifest/registrator/fields.postponed.js");
+
 const CONST_CORE_PATH = path.join(__dirname, "../../core");
 
 module.exports = class InitApp {
@@ -57,7 +59,7 @@ module.exports = class InitApp {
             });
             master.getApp().logger = logger(module, "notApplication");
         } catch (e) {
-            log.error(e);
+            log?.error(e);
         }
     }
 
@@ -70,9 +72,20 @@ module.exports = class InitApp {
             await InitApp.initCore({ config, options, master, emit });
             await InitApp.importModules({ config, options, master, emit });
             await InitApp.createReporter({ config, master });
+            this.printReportByPostponedFieldsRegistrator();
             await emit("app.post", { config, options, master });
         } catch (e) {
-            master.throwError(e.message, 1);
+            log?.error(e);
+        }
+    }
+
+    printReportByPostponedFieldsRegistrator() {
+        const report = notAppPostponedFieldsRegistrator.state();
+        if (Object.keys(report.unresolved).length) {
+            log?.error(report.unresolved);
+        }
+        if (report.insecure.length) {
+            log?.error(`List of insecure fields (${report.insecure.length}): `, report.insecure.join(', '));
         }
     }
 };

package/src/manifest/batchRunner.js

@@ -24,7 +24,7 @@ module.exports = class BatchRunner {
      * Searching for content of module and registering it.
      * @static
      * @param {Object}      input
-     * @param {notModule}   input.nModule
+     * @param {import('./module')}   input.nModule
      * @return {boolean}                       true - executed, false - no paths
      **/
     exec({ nModule }) {
@@ -32,7 +32,7 @@ module.exports = class BatchRunner {
             return false;
         }
         //starting from simpliest forms and moving upwards
-        this.#processors.forEach((processor) => new processor({ nModule }));
+        this.#processors.forEach((processor) => processor.run({ nModule }));
         return true;
     }
 };

package/src/manifest/initializator/forms.js

@@ -4,11 +4,8 @@ const { error } = require("not-log")(module, "initializator");
 module.exports = class notModuleInitializatorForms {
     static openFile = require;
 
-    constructor({ nModule }) {
-        this.run({ nModule, app: nModule.getApp() });
-    }
-
-    run({ app, nModule }) {
+    static run({ nModule }) {
+        const app = nModule.getApp();
         const moduleName = nModule.getName();
         for (let formName in nModule.getFormsConstructors()) {
             try {

package/src/manifest/initializator/manifests.js

@@ -9,11 +9,8 @@ const extractPrivateFields = (mod) =>
 
 module.exports = class notModuleInitializatorManifests {
     static openFile = require;
-    constructor({ nModule }) {
-        this.run({ nModule });
-    }
 
-    run({ nModule }) {
+    static run({ nModule }) {
         const moduleName = nModule.getName();
         for (let routeName in nModule.getRoutesManifests()) {
             try {

package/src/manifest/initializator/models.js

@@ -5,11 +5,9 @@ const { notError } = require("not-error");
 
 module.exports = class notModuleInitializatorModels {
     static openFile = require;
-    constructor({ nModule }) {
-        this.run({ nModule, app: nModule.getApp() });
-    }
 
-    run({ app, nModule }) {
+    static run({ nModule }) {
+        const app = nModule.getApp();
         const moduleName = nModule.getName();
         for (let modelName in nModule.getModels()) {
             try {

package/src/manifest/manifest.js

@@ -8,8 +8,8 @@ const notManifestFilter = require("./manifest.filter.js");
 /**
  *  API manifest
  *  @class
- *  @param  {object}   app      express application instance
- *  @param  {object}  notApp    notApplication instance
+ *  @param  {import('express').Application}   app      express application instance
+ *  @param  {import('../app.js')}  notApp    notApplication instance
  *  @param  {string}  moduleName  name of owner module
  **/
 class notManifest {
@@ -80,8 +80,7 @@ class notManifest {
 
     /**
      * Check if manifest file has url and actions, so we could register routes
-     * @param  {object}  moduleManifest    library of .manifest.js files
-     * @param  {string}  routeName         name of
+     * @param  {object}  route    library of .manifest.js files
      **/
     registerRoute(route) {
         if (!this.routeHasRoutes(route)) {

package/src/manifest/registrator/fields.js

@@ -3,15 +3,18 @@ const fs = require("fs");
 const { tryFile, objHas } = require("../../common");
 const Fields = require("../../fields");
 const { log } = require("not-log")(module, "register//fields");
+const notAppPostponedFieldsRegistrator = require("./fields.postponed");
+
 module.exports = class notModuleRegistratorFields {
     static openFile = require;
     static fieldsManager = Fields;
 
-    constructor({ nModule }) {
-        this.run({ nModule });
+    static reopenCached(pathToModule) {
+        delete this.openFile.cache[this.openFile.resolve(pathToModule)];
+        return this.openFile(pathToModule);
     }
 
-    run({ nModule }) {
+    static run({ nModule }) {
         const srcDir = notModuleRegistratorFields.getPath(nModule);
         if (!srcDir) {
             return false;
@@ -27,7 +30,7 @@ module.exports = class notModuleRegistratorFields {
         return nModule.module.paths.fields;
     }
 
-    registerFields({ nModule, lib, fromPath }) {
+    static registerFields({ nModule, lib, fromPath }) {
         for (let t in lib) {
             this.registerField({
                 nModule,
@@ -38,18 +41,75 @@ module.exports = class notModuleRegistratorFields {
         }
     }
 
-    registerField({ nModule, name, field, fromPath }) {
+    /**
+     *
+     *
+     * @param {object}  param { nModule, name, field, fromPath }
+     * @param {import('../module')}     param.nModule
+     * @param {string}                  param.name
+     * @param {object}                  param.field
+     * @param {string}                  param.fromPath
+     */
+    static registerField({ nModule, name, field, fromPath }) {
+        const MODULE_NAME = nModule.getName();
+        if (
+            notAppPostponedFieldsRegistrator.fieldShouldBePostponed(
+                field,
+                nModule
+            )
+        ) {
+            notAppPostponedFieldsRegistrator.add(
+                field.parent,
+                MODULE_NAME,
+                fromPath
+            );
+            return;
+        } else if (field.parent) {
+            const parentFieldValue =
+                notAppPostponedFieldsRegistrator.findParentField(
+                    field.parent,
+                    nModule
+                );
+            if (parentFieldValue) {
+                field = Fields.mutateField(parentFieldValue, field);
+            }
+        }
         const fieldValidatorsCount = this.extendByFrontValidators({
             name,
             field,
             fromPath: path.dirname(fromPath),
         });
         nModule.setField(name, field);
-        const MODULE_NAME = nModule.getName();
-        log(`${MODULE_NAME}//${name} with ${fieldValidatorsCount} validators`);
+        log(
+            `${MODULE_NAME}//${name} with ${fieldValidatorsCount ?? 0}/${
+                field?.model?.validate?.length ?? 0
+            } validators`
+        );
+        this.registerFieldIfInsecure(field, nModule, name);
+        notAppPostponedFieldsRegistrator.registerPostponedChildren(
+            nModule,
+            this,
+            MODULE_NAME,
+            `${MODULE_NAME}//${name}`
+        );
     }
 
-    findValidatorsFile(name, fromPath, possible_extensions = [".js", ".cjs"]) {
+    static registerFieldIfInsecure(field, nModule, name) {
+        if (
+            field.model &&
+            (!field.model.validate || field.model.validate.length === 0)
+        ) {
+            notAppPostponedFieldsRegistrator.registerInsecureField(
+                `${nModule.getName()}//${name}`
+            );
+        }
+    }
+
+    static findValidatorsFile(
+        name,
+        fromPath,
+        possible_extensions = [".js", ".cjs", ".mjs"]
+    ) {
         for (let ext of possible_extensions) {
             const validatorName = path.join(fromPath, "validators", name + ext);
             if (tryFile(validatorName)) {
@@ -62,14 +122,14 @@ module.exports = class notModuleRegistratorFields {
     /**
      *
      **/
-    extendByFrontValidators({ name, field, fromPath }) {
+    static extendByFrontValidators({ name, field, fromPath }) {
         if (!(field && objHas(field, "model"))) {
             return;
         }
         //load validators
         const validatorName = this.findValidatorsFile(name, fromPath);
         if (!validatorName) {
-            return;
+            return field?.model?.validate?.length;
         }
         const validators = notModuleRegistratorFields.openFile(validatorName);
         //inject into field.model
@@ -86,7 +146,7 @@ module.exports = class notModuleRegistratorFields {
      * @param {import('../module')}  input.nModule
      * @param {string}     input.srcDir
      **/
-    findAll({ nModule, srcDir }) {
+    static findAll({ nModule, srcDir }) {
         fs.readdirSync(srcDir).forEach((file) => {
             let fromPath = path.join(srcDir, file);
             if (!tryFile(fromPath)) {
@@ -103,7 +163,7 @@ module.exports = class notModuleRegistratorFields {
      * @param {import('../module')}  input.nModule
      * @param {string}     input.fromPath
      */
-    register({ nModule, fromPath }) {
+    static register({ nModule, fromPath }) {
         let file = notModuleRegistratorFields.openFile(fromPath);
         if (file && objHas(file, "FIELDS")) {
             //collection

package/src/manifest/registrator/fields.postponed.js

@@ -0,0 +1,194 @@
+const path = require("path");
+const getApp = require("../../getApp");
+const { mutateField } = require("../../fields");
+const { log } = require("not-log")(module, "register//fields.postponed");
+
+/**
+ * @typedef     {object}    WaitingField
+ * @property    {string}    moduleName
+ * @property    {string}    pathToField
+ */
+
+class notAppPostponedFieldsRegistrator {
+    /**
+     *
+     * @static
+     * @property {Object<strin, WaitingField>}
+     * @memberof notModuleRegistratorFields
+     */
+    static #waitingList = {};
+    static #insecureList = [];
+
+    /**
+     *
+     *
+     * @static
+     * @param {string} parentFieldName  full path to field not-module-name//not-field-name
+     * @param {string} moduleName       not-module-name
+     * @param {string} pathToField      path to field file
+     * @memberof notModuleRegistratorFields
+     */
+    static add(parentFieldName, moduleName, pathToField) {
+        const parts = path.parse(pathToField);
+        log(
+            `field ${parentFieldName} not registered yet, field ${moduleName}//${parts.name} postponed`
+        );
+        if (!Object.hasOwn(this.#waitingList, parentFieldName)) {
+            this.#waitingList[parentFieldName] = [];
+        }
+        this.#waitingList[parentFieldName].push({
+            moduleName,
+            pathToField,
+        });
+    }
+
+    /**
+     *
+     *
+     * @static
+     * @param {string} parentFieldName  full path to field not-module-name//not-field-name
+     * @return {Array<WaitingField>}
+     * @memberof notModuleRegistratorFields
+     */
+    static getChildren(parentFieldName) {
+        if (Object.hasOwn(this.#waitingList, parentFieldName)) {
+            return this.#waitingList[parentFieldName];
+        } else {
+            return [];
+        }
+    }
+
+    /**
+     * Removes all records of waiting registration fields
+     * @static
+     * @param {string} parentFieldName          full path to field not-module-name//not-field-name
+     * @memberof notAppPostponedFieldsRegistrator
+     */
+    static clearList(parentFieldName) {
+        if (Object.hasOwn(this.#waitingList, parentFieldName)) {
+            delete this.#waitingList[parentFieldName];
+        }
+    }
+
+    static findParentField(fielName, nModule) {
+        const [parentFieldModule, parentFieldName] = fielName.split("//");
+        if (parentFieldModule === nModule.getName()) {
+            return nModule.getField(parentFieldName);
+        } else {
+            return getApp().getField(fielName);
+        }
+    }
+
+    /**
+     * If parent fields exists in childField description and
+     * parent field is not registered yet - returns true
+     *
+     * @static
+     * @param {import('../../types').notField} childField
+     * @return {boolean}
+     * @memberof notAppPostponedFieldsRegistrator
+     */
+    static fieldShouldBePostponed(childField, nModule) {
+        if (Object.hasOwn(childField, "parent")) {
+            if (
+                childField.parent &&
+                typeof childField.parent === "string" &&
+                childField.parent.length > 4 &&
+                childField.parent.indexOf("//") > 0
+            ) {
+                const parentField = this.findParentField(
+                    childField.parent,
+                    nModule
+                );
+                if (!parentField) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     *  Returns lib of parent fields and depending fields paths that wasnt resolved
+     *
+     * @static
+     * @return {Object<[string], Array<string>>}
+     * @memberof notAppPostponedFieldsRegistrator
+     */
+    static state() {
+        return {
+            unresolved: this.getStateUnresolved(),
+            insecure: this.getStateInsecure(),
+        };
+    }
+
+    static getStateUnresolved() {
+        const result = {};
+        Object.keys(this.#waitingList).forEach((parentField) => {
+            result[parentField] = this.#waitingList[parentField].map(
+                (itm) => itm.pathToField
+            );
+        });
+        return result;
+    }
+
+    static getStateInsecure() {
+        return this.#insecureList;
+    }
+
+    static registerInsecureField(fullFieldName) {
+        this.#insecureList.push(fullFieldName);
+    }
+
+    /**
+     *
+     *
+     * @static
+     * @param {import('./fields')} registrator
+     * @param {string} MODULE_NAME
+     * @param {string} fullFieldName
+     * @memberof notAppPostponedFieldsRegistrator
+     */
+    static registerPostponedChildren(
+        nModuleNotRegistred,
+        registrator,
+        MODULE_NAME,
+        fullFieldName
+    ) {
+        const list = this.getChildren(fullFieldName);
+
+        if (list.length) {
+            const nModule =
+                (getApp && getApp().getModule(MODULE_NAME)) ||
+                nModuleNotRegistred;
+            log(
+                `running registration of fields (${list.length}) derived from ${fullFieldName}`
+            );
+            list.forEach((childField) => {
+                const fieldFile = registrator.reopenCached(
+                    childField.pathToField
+                );
+                const resultedField = this.mutateOriginal(
+                    fullFieldName,
+                    nModule,
+                    fieldFile
+                );
+                const parts = path.parse(childField.pathToField);
+                registrator.registerField({
+                    nModule,
+                    name: parts.name, //fields name
+                    field: resultedField, //field description
+                    fromPath: childField.pathToField,
+                });
+            });
+        }
+        this.clearList(fullFieldName);
+    }
+
+    static mutateOriginal(fullFieldName, nModule, mutator) {
+        const parentField = this.findParentField(fullFieldName, nModule);
+        return mutateField(parentField, mutator);
+    }
+}
+
+module.exports = notAppPostponedFieldsRegistrator;

package/src/manifest/registrator/forms.js

@@ -5,11 +5,7 @@ const { tryFile } = require("../../common");
 module.exports = class notModuleRegistratorForms {
     static openFile = require;
 
-    constructor({ nModule }) {
-        this.run({ nModule });
-    }
-
-    run({ nModule }) {
+    static run({ nModule }) {
         const srcDir = notModuleRegistratorForms.getPath(nModule);
         if (!srcDir) {
             return false;
@@ -31,7 +27,7 @@ module.exports = class notModuleRegistratorForms {
      * @param {string}     input.srcDir
      * @param {import('../module')} input.nModule
      **/
-    findAll({ nModule, srcDir }) {
+    static findAll({ nModule, srcDir }) {
         fs.readdirSync(srcDir).forEach((file) => {
             let fromPath = path.join(srcDir, file);
             if (!tryFile(fromPath)) {
@@ -41,7 +37,7 @@ module.exports = class notModuleRegistratorForms {
         });
     }
 
-    register({ nModule, fromPath }) {
+    static register({ nModule, fromPath }) {
         const Form = notModuleRegistratorForms.openFile(fromPath);
         const parts = path.parse(fromPath);
         nModule.setFormConstructor(parts.name, Form);

package/src/manifest/registrator/locales.js

@@ -2,17 +2,13 @@ const log = require("not-log")(module, "registrator");
 const notLocale = require("not-locale");
 
 module.exports = class notModuleRegistratorLocales {
-    constructor({ nModule }) {
-        this.run({ nModule });
-    }
-
     /**
      *
      * @param {object}                  input
      * @param {import('../module')}     input.nModule
      * @return {boolean}
      */
-    run({ nModule }) {
+    static run({ nModule }) {
         const srcDir = notModuleRegistratorLocales.getPath(nModule);
         if (!srcDir) {
             return false;

package/src/manifest/registrator/logics.js

@@ -20,11 +20,7 @@ const LOGIC_BINDINGS_LIST = [
 module.exports = class notModuleRegistratorLogics {
     static openFile = require;
 
-    constructor({ nModule }) {
-        this.run({ nModule });
-    }
-
-    run({ nModule }) {
+    static run({ nModule }) {
         const srcDir = notModuleRegistratorLogics.getPath(nModule);
         if (!srcDir) {
             return false;
@@ -47,7 +43,7 @@ module.exports = class notModuleRegistratorLogics {
      * @param {import('../module')}  input.nModule
      * @param {string}     input.srcDir
      **/
-    findAll({ nModule, srcDir }) {
+    static findAll({ nModule, srcDir }) {
         fs.readdirSync(srcDir).forEach((file) => {
             let fromPath = path.join(srcDir, file);
             //log.info(`Checking logic in ${fromPath}`);
@@ -58,7 +54,7 @@ module.exports = class notModuleRegistratorLogics {
         });
     }
 
-    register({ nModule, fromPath, file }) {
+    static register({ nModule, fromPath, file }) {
         const logic = notModuleRegistratorLogics.openFile(fromPath);
         const logicName = notModuleRegistratorLogics.getName({ logic, file });
         this.extend({ nModule, logic, logicName, fromPath });
@@ -66,7 +62,7 @@ module.exports = class notModuleRegistratorLogics {
         //log.info(`${logicName}`);
     }
 
-    extend({ nModule, logic, logicName, fromPath }) {
+    static extend({ nModule, logic, logicName, fromPath }) {
         logic.filename = fromPath;
         if (nModule.appIsSet()) {
             mapBind(nModule.getApp(), logic, LOGIC_BINDINGS_LIST);

package/src/manifest/registrator/models.js

@@ -17,11 +17,8 @@ const MODEL_BINDINGS_LIST = [
 
 module.exports = class notModuleRegistratorModels {
     static openFile = require;
-    constructor({ nModule }) {
-        this.run({ nModule });
-    }
 
-    run({ nModule }) {
+    static run({ nModule }) {
         const srcDir = notModuleRegistratorModels.getPath(nModule);
         if (!srcDir) {
             return false;
@@ -44,7 +41,7 @@ module.exports = class notModuleRegistratorModels {
      * @param {import('../module')}  input.nModule
      * @param {string}     input.srcDir
      **/
-    findAll({ nModule, srcDir }) {
+    static findAll({ nModule, srcDir }) {
         fs.readdirSync(srcDir).forEach((file) => {
             let fromPath = path.join(srcDir, file);
             //log.info(`Checking model in ${fromPath}`);
@@ -55,7 +52,7 @@ module.exports = class notModuleRegistratorModels {
         });
     }
 
-    register({ nModule, fromPath, file }) {
+    static register({ nModule, fromPath, file }) {
         const model = notModuleRegistratorModels.openFile(fromPath);
         const modelName = notModuleRegistratorModels.getName({ model, file });
         this.extend({ nModule, model, modelName, fromPath });
@@ -63,7 +60,7 @@ module.exports = class notModuleRegistratorModels {
         //log.info(`${modelName}`);
     }
 
-    extend({ nModule, model, modelName, fromPath }) {
+    static extend({ nModule, model, modelName, fromPath }) {
         model.filename = fromPath;
         if (nModule.appIsSet()) {
             mapBind(nModule.getApp(), model, MODEL_BINDINGS_LIST);

package/src/manifest/registrator/routes.js

@@ -45,11 +45,7 @@ const ROUTE_BINDINGS_LIST = [
 module.exports = class notModuleRegistratorRoutes {
     static openFile = require;
 
-    constructor({ nModule }) {
-        this.run({ nModule });
-    }
-
-    run({ nModule }) {
+    static run({ nModule }) {
         const srcDir = notModuleRegistratorRoutes.getPath(nModule);
         if (!srcDir) {
             return false;
@@ -72,13 +68,13 @@ module.exports = class notModuleRegistratorRoutes {
      * @param {import('../module')}     input.nModule
      * @param {string}                  input.srcDir
      **/
-    findAll({ nModule, srcDir }) {
+    static findAll({ nModule, srcDir }) {
         fs.readdirSync(srcDir).forEach((file) =>
             this.findOne({ nModule, file, srcDir })
         );
     }
 
-    getFileBasename(file, possible_extensions = []) {
+    static getFileBasename(file, possible_extensions = []) {
         for (let ext of possible_extensions) {
             if (file.indexOf(ext) !== -1) {
                 return file.substr(0, file.indexOf(ext));
@@ -87,7 +83,7 @@ module.exports = class notModuleRegistratorRoutes {
         return false;
     }
 
-    findOne({ nModule, srcDir, file }) {
+    static findOne({ nModule, srcDir, file }) {
         try {
             //если имя похоже на название манифеста
             const routeBasename = this.getFileBasename(
@@ -171,7 +167,7 @@ module.exports = class notModuleRegistratorRoutes {
         return false;
     }
 
-    registerManifestAndRoutes({
+    static registerManifestAndRoutes({
         nModule,
         routeName,
         routeManifest,
@@ -195,7 +191,7 @@ module.exports = class notModuleRegistratorRoutes {
         }
     }
 
-    registerRoute({ nModule, route, routeName }) {
+    static registerRoute({ nModule, route, routeName }) {
         nModule.setRoute(route.thisRouteName, route);
         if (nModule.appIsSet()) {
             mapBind(nModule.getApp(), route, ROUTE_BINDINGS_LIST);
@@ -204,8 +200,8 @@ module.exports = class notModuleRegistratorRoutes {
         route.getThisModule = () => nModule;
     }
 
-    registerWSRoute({ nModule, wsRoute }) {
-        new notModuleRegistratorRoutesWS({
+    static registerWSRoute({ nModule, wsRoute }) {
+        notModuleRegistratorRoutesWS.run({
             nModule,
             wsRoute: wsRoute,
             wsRouteName: wsRoute.thisRouteName,