taon 21.0.52 → 21.0.53

package/lib-prod/realtime/realtime-strategy/realtime-strategy-mock.js

@@ -0,0 +1,262 @@
+import { RealtimeStrategy } from "./realtime-strategy";
+import { Symbols__NS__REALTIME } from "../../symbols";
+class MockServer {
+  //#region constructor
+  constructor(url) {
+    this.url = url;
+    MockServer.serverByUrl.set(url, this);
+  }
+  static serverByUrl = /* @__PURE__ */ new Map();
+  static from(url) {
+    if (!MockServer.serverByUrl.has(url)) {
+      MockServer.serverByUrl.set(url, new MockServer(url));
+    }
+    return MockServer.serverByUrl.get(url);
+  }
+  get allServers() {
+    return Array.from(MockServer.serverByUrl.values());
+  }
+  namespacesByName = /* @__PURE__ */ new Map();
+  //#endregion
+  //#region of
+  of(namespace) {
+    if (!this.namespacesByName.has(namespace)) {
+      this.namespacesByName.set(namespace, new MockNamespace(namespace, this));
+    }
+    return this.namespacesByName.get(namespace);
+  }
+  //#endregion
+  //#region path
+  path() {
+    return this.url;
+  }
+  //#endregion
+}
+class MockNamespace {
+  //#region constructor
+  constructor(name, server) {
+    this.name = name;
+    this.server = server;
+  }
+  /**
+   * All sockets connected to this namespace
+   */
+  allSocketsForNamespace = /* @__PURE__ */ new Set();
+  /**
+   * Rooms and their sockets
+   */
+  socketByRoomName = {};
+  /**
+   * Event handlers for this namespace
+   */
+  namespaceEventHandlers = {};
+  //#endregion
+  //#region on
+  on(eventName, handler) {
+    if (!this.namespaceEventHandlers[eventName]) {
+      this.namespaceEventHandlers[eventName] = /* @__PURE__ */ new Set();
+    }
+    if (!this.namespaceEventHandlers[eventName].has(handler)) {
+      this.namespaceEventHandlers[eventName].add(handler);
+    }
+    if (eventName === "connection") {
+      setTimeout(() => {
+        this.emit("connection", this);
+      });
+    }
+  }
+  //#endregion
+  //#region emit
+  emit(event, ...args) {
+    this.allSocketsForNamespace?.forEach((socket) => {
+      socket.emit(event, ...args);
+    });
+  }
+  //#endregion
+  //#region connect
+  connect(socket) {
+    this.allSocketsForNamespace.add(socket);
+    socket.namespaceInstance = this;
+  }
+  //#endregion
+  //#region to
+  to(roomName) {
+    const socketsInRoom = this.socketByRoomName[roomName];
+    return new RoomEmitter(socketsInRoom, true);
+  }
+  //#endregion
+  //#region to room
+  in(roomName) {
+    const socketsInRoom = this.socketByRoomName[roomName];
+    return new RoomEmitter(socketsInRoom, false);
+  }
+  //#endregion
+  //#region join room
+  joinRoom(roomName, socket) {
+    if (!this.socketByRoomName[roomName]) {
+      this.socketByRoomName[roomName] = /* @__PURE__ */ new Set();
+    }
+    this.socketByRoomName[roomName].add(socket);
+  }
+  //#endregion
+  //#region leave room
+  leaveRoom(roomName, socket) {
+    const roomSockets = this.socketByRoomName[roomName];
+    if (roomSockets) {
+      this.socketByRoomName[roomName].delete(socket);
+    }
+  }
+  //#endregion
+  //#region nsp + name
+  get nsp() {
+    const self = this;
+    return {
+      get name() {
+        return self.name;
+      }
+    };
+  }
+  //#endregion
+  path() {
+    return this.name;
+  }
+}
+class RoomEmitter {
+  //#region constructor
+  constructor(sockets, includeSender = false, sender = null) {
+    this.sockets = sockets;
+    this.includeSender = includeSender;
+    this.sender = sender;
+  }
+  //#endregion
+  //#region emit in room
+  emit(event, ...args) {
+    this.sockets?.forEach((socket) => {
+      if (this.includeSender || socket !== this.sender) {
+        socket.emit(event, ...args);
+      }
+    });
+  }
+  //#endregion
+}
+class MockSocket {
+  //#region constructor
+  constructor(url, opts) {
+    this.url = url;
+    const [baseUrl, namespace] = [url, opts.path || "/"];
+    const namespaceName = namespace || "/";
+    const server = MockServer.from(url);
+    const ns = server.of(namespaceName);
+    ns.connect(this);
+  }
+  namespaceInstance;
+  socketEventHandlers = {};
+  get id() {
+    return this.nsp.name;
+  }
+  //#endregion
+  //#region nsp + name
+  get nsp() {
+    const self = this;
+    return {
+      get name() {
+        return self.namespaceInstance?.name;
+      }
+    };
+  }
+  //#endregion
+  //#region path
+  path() {
+    return this.namespaceInstance?.name;
+  }
+  //#endregion
+  //#region on
+  on(eventName, handler) {
+    if (!this.socketEventHandlers[eventName]) {
+      this.socketEventHandlers[eventName] = /* @__PURE__ */ new Set();
+    }
+    this.socketEventHandlers[eventName].add(handler);
+    if (eventName === "connect") {
+      setTimeout(() => {
+        this.emit("connect");
+      });
+    }
+  }
+  //#endregion
+  //#region emit
+  emit(eventName, ...args) {
+    eventName = eventName || "";
+    if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomSubscribe}`)) {
+      const room = args[0];
+      this.join(room);
+    } else if (eventName.includes(`:${Symbols__NS__REALTIME.KEYroomUnsubscribe}`)) {
+      const room = args[0];
+      this.leave(room);
+    } else {
+      if (this.namespaceInstance) {
+        const namespaceEventHandlers = this.namespaceInstance.namespaceEventHandlers[eventName] || [];
+        for (const namespaceEventHandler of namespaceEventHandlers) {
+          if (namespaceEventHandler) {
+            namespaceEventHandler(...args);
+          }
+        }
+        const allSocketsForNamespaceExceptCurrent = Array.from(
+          this.namespaceInstance.allSocketsForNamespace.values()
+        ).filter((socket) => socket !== this);
+        for (const socket of allSocketsForNamespaceExceptCurrent) {
+          const socketEventHandlers2 = socket.socketEventHandlers[eventName];
+          for (const socketEventHandler of socketEventHandlers2) {
+            if (socketEventHandler) {
+              socketEventHandler(...args);
+            }
+          }
+        }
+        const socketEventHandlers = this.socketEventHandlers[eventName] || [];
+        for (const clientHandler of socketEventHandlers) {
+          if (clientHandler) {
+            clientHandler(...args);
+          }
+        }
+      }
+    }
+  }
+  //#endregion
+  //#region join room
+  join(roomName) {
+    this.namespaceInstance.joinRoom(roomName, this);
+  }
+  //#endregion
+  //#region leave room
+  leave(roomName) {
+    this.namespaceInstance.leaveRoom(roomName, this);
+  }
+  //#endregion
+}
+class RealtimeStrategyMock extends RealtimeStrategy {
+  //#endregion
+  //#region constructor
+  constructor(ctx) {
+    super(ctx);
+    this.ctx = ctx;
+  }
+  //#region toString
+  toString() {
+    return "mock";
+  }
+  //#endregion
+  //#region server & io
+  ioServer(url, opt) {
+    const server = MockServer.from(url || this.ctx.uriOrigin);
+    return server.of(opt?.path || "/");
+  }
+  get ioClient() {
+    const clientIo = (uri, opts) => {
+      return new MockSocket(uri || this.ctx.uriOrigin, opts);
+    };
+    return clientIo;
+  }
+  //#endregion
+}
+export {
+  RealtimeStrategyMock
+};

package/lib-prod/realtime/realtime-strategy/realtime-strategy-socket-io.js

@@ -0,0 +1,21 @@
+import { RealtimeStrategy } from "./realtime-strategy";
+import { Server } from "socket.io";
+import { io } from "socket.io-client";
+class RealtimeStrategySocketIO extends RealtimeStrategy {
+  constructor(ctx) {
+    super(ctx);
+    this.ctx = ctx;
+  }
+  toString() {
+    return "socket-io";
+  }
+  ioServer(...args) {
+    return new Server(...args);
+  }
+  get ioClient() {
+    return io;
+  }
+}
+export {
+  RealtimeStrategySocketIO
+};

package/lib-prod/realtime/realtime-strategy/realtime-strategy.js

@@ -0,0 +1,14 @@
+class RealtimeStrategy {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  get ioClient() {
+    throw new Error("Not implemented");
+  }
+  ioServer(url, opt) {
+    throw new Error("Not implemented");
+  }
+}
+export {
+  RealtimeStrategy
+};

package/lib-prod/realtime/realtime-subs-manager.js

@@ -0,0 +1,96 @@
+import { ___NS__isString } from "tnp-core/lib-prod";
+import { Symbols__NS__REALTIME } from "../symbols";
+class RealtimeSubsManager {
+  constructor(options) {
+    this.options = options;
+  }
+  isListening = false;
+  observers = [];
+  //#region methods & getters / start listen if not started
+  startListenIfNotStarted(realtime) {
+    if (this.options.core.ctx.disabledRealtime) {
+      console.warn(`[Taon][startListenIfNotStarted] sockets are disabled`);
+      return;
+    }
+    if (!realtime) {
+      console.warn(`[Taon][startListenIfNotStarted] invalid socket connection`);
+      return;
+    }
+    if (!this.isListening) {
+      this.isListening = true;
+      if (this.options.customEvent) {
+        const subscribeEvent = Symbols__NS__REALTIME.ROOM_SUBSCRIBE_CUSTOM(
+          this.options.core.ctx.contextName
+        );
+        realtime.emit(subscribeEvent, this.options.roomName);
+      } else {
+        if (___NS__isString(this.options.property)) {
+          const subscribeEvent = Symbols__NS__REALTIME.ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(
+            this.options.core.ctx.contextName
+          );
+          realtime.emit(subscribeEvent, this.options.roomName);
+        } else {
+          const subscribeEvent = Symbols__NS__REALTIME.ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(
+            this.options.core.ctx.contextName
+          );
+          realtime.emit(subscribeEvent, this.options.roomName);
+        }
+      }
+      realtime.on(this.options.roomName, (data) => {
+        this.update(data);
+      });
+    }
+  }
+  //#endregion
+  //#region methods & getters / add observer
+  add(observer) {
+    this.observers.push(observer);
+  }
+  //#endregion
+  //#region methods & getters / remove observer
+  remove(observer) {
+    this.observers = this.observers.filter((obs) => obs !== observer);
+    if (this.observers.length === 0) {
+      this.isListening = false;
+      const { core, customEvent, roomName, property } = this.options;
+      const realtime = core.socketFE;
+      if (customEvent) {
+        realtime.emit(
+          Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_CUSTOM(
+            this.options.core.ctx.contextName
+          ),
+          roomName
+        );
+      } else {
+        if (___NS__isString(property)) {
+          realtime.emit(
+            Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(
+              this.options.core.ctx.contextName
+            ),
+            roomName
+          );
+        } else {
+          realtime.emit(
+            Symbols__NS__REALTIME.ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(
+              this.options.core.ctx.contextName
+            ),
+            roomName
+          );
+        }
+      }
+    }
+  }
+  //#endregion
+  //#region methods & getters / update
+  update(data) {
+    this.observers.forEach((observer) => {
+      if (!observer.closed) {
+        observer.next(data);
+      }
+    });
+  }
+  //#endregion
+}
+export {
+  RealtimeSubsManager
+};

package/lib-prod/symbols.js

@@ -0,0 +1,109 @@
+import { OrignalClassKey } from "taon-typeorm/lib-prod";
+import { ___NS__camelCase } from "tnp-core/lib-prod";
+import { SYMBOL } from "typescript-class-helpers/lib-prod";
+class Realtime {
+  NAMESPACE(contextName) {
+    return `${contextName}-taonRealtimeNsp`;
+  }
+  TABLE_CHANGE(contextName, tableName) {
+    return `${contextName}:listentablename${tableName}`;
+  }
+  KEYroomSubscribe = `roomSubscribe`;
+  KEYroomUnsubscribe = `roomUnsubscribe`;
+  // /**
+  //  * TODO use it or not?
+  //  * @deprecated
+  //  */
+  // ROOM_NAME_SUBSCRIBER_EVENT(
+  //   contextName: string,
+  //   className: string,
+  //   propertyName: string,
+  // ) {
+  //   return `${contextName}:room${___NS__camelCase(className)}${propertyName}`.toLowerCase();
+  // }
+  //#region custom events in rooms
+  ROOM_NAME_CUSTOM(contextName, customEvent) {
+    return `${contextName}:CustomRoomEvent${customEvent}`;
+  }
+  ROOM_SUBSCRIBE_CUSTOM(contextName) {
+    return `${contextName}:${this.KEYroomSubscribe}CustomRoomEvent`;
+  }
+  ROOM_UNSUBSCRIBE_CUSTOM(contextName) {
+    return `${contextName}:${this.KEYroomUnsubscribe}CustomRoomEvent`;
+  }
+  //#endregion
+  //#region entity events
+  ROOM_NAME_UPDATE_ENTITY(contextName, className, entityId) {
+    return `${contextName}:room${___NS__camelCase(className)}${entityId}`.toLowerCase();
+  }
+  ROOM_SUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
+    return `${contextName}:${this.KEYroomSubscribe}EntityEvents`;
+  }
+  ROOM_UNSUBSCRIBE_ENTITY_UPDATE_EVENTS(contextName) {
+    return `${contextName}:${this.KEYroomUnsubscribe}EntityEvents`;
+  }
+  //#endregion
+  //#region entity property events
+  ROOM_NAME_UPDATE_ENTITY_PROPERTY(contextName, className, property, entityId) {
+    return `${contextName}:room${___NS__camelCase(className)}${___NS__camelCase(property)}${entityId}`.toLowerCase();
+  }
+  ROOM_SUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
+    return `${contextName}:${this.KEYroomSubscribe}EntityPropertyEvents`;
+  }
+  ROOM_UNSUBSCRIBE_ENTITY_PROPERTY_UPDATE_EVENTS(contextName) {
+    return `${contextName}:${this.KEYroomUnsubscribe}EntityPropertyEvents`;
+  }
+  //#endregion
+}
+const Symbols__NS__ctxInClassOrClassObj = Symbol();
+const Symbols__NS__classNameStaticProperty = SYMBOL.ClassNameStaticProperty;
+const Symbols__NS__fullClassNameStaticProperty = `$$fullclassName$$`;
+const Symbols__NS__orignalClass = OrignalClassKey;
+const Symbols__NS__orignalClassClonesObj = `$$originalClassClonesObj$$`;
+const Symbols__NS__classMethodsNames = `$$classMethodsNames$$`;
+const Symbols__NS__REALTIME = new Realtime();
+const Symbols__NS__metadata = {
+  className: `class:realname`,
+  options: {
+    controller: `controller:options`,
+    entity: `entity:options`,
+    repository: `repository:options`,
+    provider: `provider:options`,
+    subscriber: `subscriber:options`,
+    migration: `migration:options`
+  }
+};
+const Symbols__NS__old = {
+  HAS_TABLE_IN_DB: Symbol(),
+  MDC_KEY: `modeldataconfig`,
+  WEBSQL_REST_PROGRESS_FUN: Symbol(),
+  WEBSQL_REST_PROGRESS_FUN_START: Symbol(),
+  WEBSQL_REST_PROGRESS_FUN_DONE: Symbol(),
+  WEBSQL_REST_PROGRESS_TIMEOUT: Symbol(),
+  X_TOTAL_COUNT: `x-total-count`,
+  CIRCURAL_OBJECTS_MAP_BODY: `circuralmapbody`,
+  CIRCURAL_OBJECTS_MAP_QUERY_PARAM: `circuralmapbody`,
+  MAPPING_CONFIG_HEADER: `mappingheader`,
+  MAPPING_CONFIG_HEADER_BODY_PARAMS: `mhbodyparams`,
+  MAPPING_CONFIG_HEADER_QUERY_PARAMS: `mhqueryparams`,
+  ENDPOINT_META_CONFIG: `ng2_rest_endpoint_config`,
+  CLASS_DECORATOR_CONTEXT: `$$ng2_rest_class_context`,
+  SOCKET_MSG: `socketmessageng2rest`,
+  ANGULAR: {
+    INPUT_NAMES: Symbol()
+  },
+  ERROR_MESSAGES: {
+    CLASS_NAME_MATCH: `Please check if your "class name" matches  @Controller( className ) or @Entity( className )`
+  }
+};
+export {
+  Symbols__NS__REALTIME,
+  Symbols__NS__classMethodsNames,
+  Symbols__NS__classNameStaticProperty,
+  Symbols__NS__ctxInClassOrClassObj,
+  Symbols__NS__fullClassNameStaticProperty,
+  Symbols__NS__metadata,
+  Symbols__NS__old,
+  Symbols__NS__orignalClass,
+  Symbols__NS__orignalClassClonesObj
+};

package/lib-prod/ui/index.js

@@ -0,0 +1,5 @@
+function dummy1769816172730() {
+}
+export {
+  dummy1769816172730
+};

package/lib-prod/ui/taon-admin-mode-configuration/index.js

@@ -0,0 +1,5 @@
+function dummy1769816173545() {
+}
+export {
+  dummy1769816173545
+};

package/lib-prod/validators.js

@@ -0,0 +1,74 @@
+import { ___NS__isArray, ___NS__isFunction, ___NS__isUndefined } from "tnp-core/lib-prod";
+const Validators__NS__classNameVlidation = (className, target) => {
+  setTimeout(() => {
+    if (___NS__isUndefined(className)) {
+      throw `[Taon]
+      Please provide "className" property for each Controller and Entity:
+
+          @Taon.Controller({ className: 'MyExampleCtrl'  })
+          class MyExampleCtrl {
+            ...
+          }
+
+          @Taon.Entity({ className: 'MyExampleEntity'  })
+          class MyExampleEntity {
+            ...
+          }
+
+    Notice that minified javascript code does not preserve
+    Functions/Classes names -this is only solution to preserve classes names.
+
+        `;
+    }
+  });
+  return ___NS__isUndefined(className) ? target.name : className;
+};
+const Validators__NS__checkIfMethodsWithReponseTYpeAlowed = (methods, current) => {
+  const defaultResponseType = "text or JSON";
+  if (!current.responseType) {
+    return;
+  }
+  for (let index = 0; index < methods.length; index++) {
+    const m = methods[index];
+    if (m.path === current.path && m.responseType !== current.responseType) {
+      throw new Error(`
+  [taon] you can have 2 methods with same path but differetn reponseType-s
+
+          ${m.methodName}( ... path: ${m.path} )  -> responseType: ${m.responseType || defaultResponseType}
+          ${current.methodName}( ... path: ${current.path} ) -> responseType: ${current.responseType}
+
+    Please change path name on of the methods.
+
+        `);
+    }
+  }
+};
+const Validators__NS__validateClassFunctions = (controllers, entities, proviers, repositories) => {
+  if (___NS__isArray(controllers) && controllers.filter((f) => !___NS__isFunction(f)).length > 0) {
+    console.error("controllers", controllers);
+    throw `
+
+  Incorect value for property "controllers" inside Taon.Init(...)
+
+  `;
+  }
+  if (___NS__isArray(entities) && entities.filter((f) => !___NS__isFunction(f)).length > 0) {
+    console.error("entites", entities);
+    throw `
+
+  Incorect value for property "entities" inside Taon.Init(...)
+
+  `;
+  }
+};
+const Validators__NS__preventUndefinedModel = (model, id) => {
+  if (___NS__isUndefined(model)) {
+    throw `Bad update by id, config, id: ${id}`;
+  }
+};
+export {
+  Validators__NS__checkIfMethodsWithReponseTYpeAlowed,
+  Validators__NS__classNameVlidation,
+  Validators__NS__preventUndefinedModel,
+  Validators__NS__validateClassFunctions
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon",
-  "version": "21.0.52",
+  "version": "21.0.53",
   "scripts": {
     "mkdocs": "python3 -m mkdocs",
     "taon init": "taon init",

package/websql/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon/websql",
-  "version": "21.0.52",
+  "version": "21.0.53",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/websql-prod/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taon/websql-prod",
-  "version": "21.0.52",
+  "version": "21.0.53",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"

package/lib-prod/base-classes/base-abstract-entity.ts

@@ -1,34 +0,0 @@
-import { Entity, VersionColumn } from 'taon-typeorm/lib-prod'; // @websql
-
-import {
-  Generated,
-  GeneratedColumn,
-  PrimaryColumn,
-  PrimaryGeneratedColumn,
-  VirtualColumn,
-} from '../orm';
-
-import type { TaonBaseClass } from './base-class';
-import { TaonBaseEntity } from './base-entity';
-
-//#region @websql
-@Entity()
-//#endregion
-export abstract class TaonBaseAbstractEntity<
-  CloneT extends TaonBaseClass = any,
-> extends TaonBaseEntity<CloneT> {
-  //#region @websql
-  @PrimaryGeneratedColumn()
-  //#endregion
-  id: string;
-
-  //#region @websql
-  @VersionColumn()
-  //#endregion
-  version: number;
-}
-
-export type AbstractEntityOmitKeys<ENTITY> = Omit<
-  ENTITY,
-  'id' | 'version' | '_' | 'clone'
->;