not-node 6.5.26 → 6.5.28

package/package.json

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

package/src/exceptions/action.js

@@ -20,6 +20,18 @@ class ActionExceptionPipeExecutionError extends notRequestError {
 module.exports.ActionExceptionPipeExecutionError =
     ActionExceptionPipeExecutionError;
 
+class ActionExceptionIdentitySessionIsNotDefined extends notRequestError {
+    constructor(actionName, identity) {
+        super(
+            "User identity `sid` is not defined",
+            { code: 505, params: { actionName, identity } },
+            null
+        );
+    }
+}
+module.exports.ActionExceptionIdentitySessionIsNotDefined =
+    ActionExceptionIdentitySessionIsNotDefined;
+
 class OwnageExceptionIdentityUserIdIsNotDefined extends notRequestError {
     constructor(actionName, identity) {
         super(

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,17 @@ 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.report();
+        if (Object.keys(report).length) {
+            log?.error(report);
         }
     }
 };

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,44 @@ 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)) {
+            notAppPostponedFieldsRegistrator.add(
+                field.parent,
+                MODULE_NAME,
+                fromPath
+            );
+            return;
+        }
         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`);
+        notAppPostponedFieldsRegistrator.registerPostponedChildren(
+            this,
+            MODULE_NAME,
+            `${MODULE_NAME}//${name}`
+        );
     }
 
-    findValidatorsFile(name, fromPath, possible_extensions = [".js", ".cjs"]) {
+    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 +91,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 +115,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 +132,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,133 @@
+const path = require("path");
+const getApp = require("../../getApp");
+
+/**
+ * @typedef     {object}    WaitingField
+ * @property    {string}    moduleName
+ * @property    {string}    pathToField
+ */
+
+class notAppPostponedFieldsRegistrator {
+    /**
+     *
+     * @static
+     * @property {Object<strin, WaitingField>}
+     * @memberof notModuleRegistratorFields
+     */
+    static #waitingList = {};
+
+    /**
+     *
+     *
+     * @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) {
+        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];
+        }
+    }
+
+    /**
+     * 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) {
+        if (Object.hasOwn(childField, "parent")) {
+            if (
+                childField.parent &&
+                typeof childField.parent === "string" &&
+                childField.parent.length > 4 &&
+                childField.parent.indexOf("//") > 0
+            ) {
+                const parentField = getApp().getField(childField.parent);
+                return !parentField;
+            }
+        }
+        return false;
+    }
+
+    /**
+     *  Returns lib of parent fields and depending fields paths that wasnt resolved
+     *
+     * @static
+     * @return {Object<[string], Array<string>>}
+     * @memberof notAppPostponedFieldsRegistrator
+     */
+    static state() {
+        const result = {};
+        Object.keys(this.#waitingList).forEach((parentField) => {
+            result[parentField] = this.#waitingList.map(
+                (itm) => itm.pathToField
+            );
+        });
+        return result;
+    }
+
+    /**
+     *
+     *
+     * @static
+     * @param {import('./fields')} registrator
+     * @param {string} MODULE_NAME
+     * @param {string} fullFieldName
+     * @memberof notAppPostponedFieldsRegistrator
+     */
+    static registerPostponedChildren(registrator, MODULE_NAME, fullFieldName) {
+        const list = this.getChildren(fullFieldName);
+        list.forEach((childField) => {
+            const nModule = getApp().getModule(MODULE_NAME);
+            const fieldFile = registrator.reopenCached(childField.pathToField);
+            const parts = path.parse(childField.pathToField);
+            registrator.registerField({
+                nModule,
+                name: parts.name, //fields name
+                field: fieldFile, //field description
+                fromPath: childField.pathToField,
+            });
+        });
+        this.clearList(fullFieldName);
+    }
+}
+
+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,

package/src/manifest/registrator/routes.ws.js

@@ -3,7 +3,7 @@ const { mapBind, objHas } = require("../../common");
 /**
  * List of methods to be binded from notApp to routes and WS end-points
  * @constant
- * @type {string}
+ * @type {Array<string>}
  */
 const WS_ROUTE_BINDINGS_LIST = [
     "getLogic",
@@ -15,15 +15,7 @@ const WS_ROUTE_BINDINGS_LIST = [
 ];
 
 module.exports = class notModuleRegistratorRoutesWS {
-    constructor({ nModule, wsRoute, wsRouteName }) {
-        this.run({
-            nModule,
-            wsRoute,
-            wsRouteName,
-        });
-    }
-
-    run({ nModule, wsRoute, wsRouteName }) {
+    static run({ nModule, wsRoute, wsRouteName }) {
         if (nModule.appIsSet()) {
             const input = {
                 nModule,
@@ -35,21 +27,26 @@ module.exports = class notModuleRegistratorRoutesWS {
         }
     }
 
-    registerServers(input) {
+    static registerServers(input) {
         this.registerCollectionType({
             ...input,
             collectionType: "servers",
         });
     }
 
-    registerClients(input) {
+    static registerClients(input) {
         this.registerCollectionType({
             ...input,
             collectionType: "clients",
         });
     }
 
-    registerCollectionType({ nModule, wsRoute, wsRouteName, collectionType }) {
+    static registerCollectionType({
+        nModule,
+        wsRoute,
+        wsRouteName,
+        collectionType,
+    }) {
         if (!objHas(wsRoute, collectionType)) {
             return false;
         }
@@ -65,7 +62,7 @@ module.exports = class notModuleRegistratorRoutesWS {
         return true;
     }
 
-    registerCollectionItem({
+    static registerCollectionItem({
         nModule,
         wsRoute,
         wsRouteName,
@@ -84,7 +81,7 @@ module.exports = class notModuleRegistratorRoutesWS {
         });
     }
 
-    registerEndPoints({
+    static registerEndPoints({
         nModule,
         wsRouteName,
         collectionType,

package/src/types.js

@@ -180,6 +180,7 @@
 
 /**
  * @typedef     {object} notField
+ * @property    {string}            [parent]    field name in full form not-module-name//field-name
  * @property    {notFieldUI}        [ui]
  * @property    {notFieldModel}     [model]
  */