@social-mail/social-mail-hosted-web 1.0.2

package/node_modules/@web-atoms/entity/src/models/ChangeSet.ts

@@ -0,0 +1,139 @@
+const changeSet = Symbol("changeSet");
+
+const copyBasicProperties = (target, source) => {
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            const element = source[key];
+            switch(typeof element) {
+                case "object":
+                    if (element instanceof Date) {
+                        target[key] = element;
+                    }
+                    break;
+                case "symbol":
+                case "function":
+                    break;
+                default:
+                    target[key] = element;
+                    break;
+            }
+        }
+    }
+};
+
+/**
+ * ChangeSet represents set of changes made
+ * to entity graph.
+ * 
+ * This is important if we want to make changes and 
+ * we want to undo changes as well as support
+ * binding and updates.
+ */
+export default class ChangeSet<T extends object = any> implements ProxyHandler<any> {
+
+    public modified: boolean = false;
+
+    public static create<T extends object = any>(entity: T) {
+        return new ChangeSet(entity);
+    }
+
+    public readonly editable: any;
+
+    public readonly included: Set<any>;
+
+    public readonly changes: any;
+
+    constructor(
+        public readonly entity: T,
+        included: Iterable<any> = [entity],
+        private readonly parent?: ChangeSet
+    ){
+        this.included = new Set(included);
+        this.changes = Array.isArray(entity) ? [] : {};
+        this.editable = new Proxy(this.changes, this);
+        this.changes[changeSet] = this;
+    }
+
+    get(target: any, p: string | symbol, receiver: any) {
+
+        if (typeof p === "symbol" && p === changeSet) {
+            return this;
+        }
+        let cs = this.changes[p]?.[changeSet];
+        if (cs) {
+            return cs.editable;
+        }
+        const value = Reflect.get(this.entity, p) as any;
+        cs = value?.[changeSet];
+        if (cs) {
+            return cs.editable;
+        }
+        if (value?.$type || Array.isArray(value)) {
+            return this.createNewEntry(value, p).editable;
+        }
+        return value;
+    }
+
+    set(target: any, p: string | symbol, newValue: any, receiver: any): boolean {
+
+        if (newValue[changeSet]) {
+            // this should only be set while committing an object..not before that...
+            return;
+        }
+
+
+        if (newValue?.$type || Array.isArray(newValue)) {
+            // we need to create a change link...
+            // if not included....
+            this.setModified();
+            
+            this.createNewEntry(newValue, p);
+            return true;
+        }
+        if (!this.modified) {
+            this.setModified();
+        }
+        this.changes[p] = newValue;
+        return true;
+    }
+
+    private createNewEntry(value: any, p?) {
+        if (this.included.has(value)) {
+            // something is seriously wrong...
+            throw new Error("Invalid operation");
+        }
+        this.included.add(value);
+
+        // create new change set...
+        const cs = new ChangeSet(value, this.included, this);
+
+        if (Array.isArray(value)) {
+
+            // accessing array means it may be modified...
+            // we will not set it as modified.. but we will add items to the array
+            for (let index = 0; index < value.length; index++) {
+                const element = value[index];
+                const ep = this.createNewEntry(element);
+                cs.changes[index] = ep.changes;
+            }
+
+            this.changes[p] = cs.changes;
+
+        } else if (p !== void 0) {
+            this.changes[p] = cs.changes;
+        }
+
+        return cs;
+    }
+
+    private setModified() {
+        if (!this.modified) {
+            if (!Array.isArray(this.entity)) {
+                copyBasicProperties(this.changes, this.entity);
+            }
+            this.modified = true;
+        }
+        this.parent?.setModified();
+    }
+
+}

package/node_modules/@web-atoms/entity/src/models/Cloner.ts

@@ -0,0 +1,114 @@
+import { ICollection } from "../services/BaseEntityService";
+import cloneSource from "./cloneSource";
+
+const getKey = (target, value) => {
+    for (const key in target) {
+        if (Object.prototype.hasOwnProperty.call(target, key)) {
+            const element = target[key];
+            if (element === value) {
+                return key;
+            }
+        }
+    }
+};
+
+export type PropertyPath = Array<(item) => any>;
+
+/* eslint-disable @typescript-eslint/unified-signatures */
+export class Cloner<T> {
+
+    protected static copyProperties(src, dest = {}) {
+        dest[cloneSource] = src;
+        for (const key in src) {
+            if (Object.prototype.hasOwnProperty.call(src, key)) {
+                const element = src[key];
+                switch(typeof element) {
+                    case "bigint":
+                    case "boolean":
+                    case "number":
+                    case "string":
+                        dest[key] = element;
+                        break;
+                    case "object":
+                        if (element === null){
+                            dest[key] = null;
+                        }
+                        if (element instanceof Date) {
+                            dest[key] = element;
+                        }
+                        break;
+                }
+            }
+        }
+        return dest;
+    }
+
+    public readonly $type: string;
+
+    public get copy(): T {
+
+        const copy = Cloner.copyProperties(this.item);
+        if (this.path) {
+            for (const iterator of this.path) {
+                this.clone(this.item, copy, iterator);
+            }
+        }
+        return copy as any;
+    }
+
+    constructor(protected item: T, protected path?: PropertyPath[]) {
+        this.$type = (item as any).$type;
+    }
+
+    public include<TProperty>(property: (item: T) => ICollection<TProperty> | TProperty): PropertyCloner<T, TProperty>;
+    // public include<TProperty>(property: (item: T) => TProperty[]): PropertyCloner<T, TProperty>;
+    // public include<TProperty>(property: (item: T) => TProperty): PropertyCloner<T, TProperty>;
+    public include<TProperty>(property: any): PropertyCloner<T, TProperty> {
+        const last = [property];
+        return new PropertyCloner(this.item, this.path ? [... this.path, last]: [last], last);
+    }
+
+    private clone(src, dest, paths) {
+        if (!paths.length) {
+            return dest;
+        }
+        const [first, ... others] = paths;
+        let p = first(src);
+        if (!p) {
+            return dest;
+        }
+        const original = p;
+        const name = getKey(src, p);
+        if (Array.isArray(p)) {
+            const existing = dest[name] ??= [];
+            for (let index = 0; index < p.length; index++) {
+                const element = p[index];
+                const existingItem = existing[index] ??= {};
+                Cloner.copyProperties(element, existingItem);
+                this.clone(element, existingItem, others);
+            }
+            return existing;
+        }
+
+        p = Cloner.copyProperties(p, dest[name] ?? undefined);
+        dest[name] = p;
+        this.clone(original, p, others);
+        return dest;
+    }
+
+}
+
+export class PropertyCloner<T, TPrevious> extends Cloner<T> {
+
+    constructor(item: T, path: PropertyPath[], private propertyPath: PropertyPath) {
+        super(item, path);
+    }
+
+    public thenInclude<TProperty>(
+        property: (item: TPrevious) => ICollection<TProperty> | TProperty): PropertyCloner<T, TProperty>;
+    public thenInclude<TProperty>(property: any): PropertyCloner<T, TProperty> {
+        this.propertyPath.push(property);
+        return new PropertyCloner(this.item, this.path, this.propertyPath);
+    }
+
+}

package/node_modules/@web-atoms/entity/src/models/IClrEntity.ts

@@ -0,0 +1,24 @@
+export interface IProperties {
+    [key: string]: string | number | null | undefined;
+}
+
+export interface INavigationProperties {
+    [key: string]: {
+        add?: IClrEntity[],
+        remove?: IClrEntity[],
+        clear?: boolean,
+        set?: IClrEntity
+    };
+}
+
+export default interface IClrEntity {
+    $type: string;
+    $deleted?: boolean;
+    $navigations?: INavigationProperties;
+}
+
+export type IClrEntityLike<T> = Omit<T, "$type">;
+
+export interface IClrExtendedEntity {
+    [key: string]: any;
+}

package/node_modules/@web-atoms/entity/src/models/IEntityModel.ts

@@ -0,0 +1,35 @@
+export interface IEntityKey {
+    name: string;
+    type: string;
+}
+
+export interface IEntityPropertyInfo extends IEntityKey {
+    isNullable?: boolean;
+}
+
+export interface IEntityNavigationProperty extends IEntityKey {
+    isCollection?: boolean;
+}
+
+export default interface IEntityModel {
+    name?: string;
+    keys?: IEntityKey[];
+    properties?: IEntityPropertyInfo[];
+    navigationProperties?: IEntityNavigationProperty[];
+}
+
+export class EntityContext {
+    public models: IEntityModel[];
+    private cache: any;
+    constructor(models: IEntityModel[]) {
+        this.models = models;
+        this.cache = [];
+        for (const iterator of models) {
+            this.cache[iterator.name] = iterator;
+        }
+    }
+
+    public for(name: string): IEntityModel {
+        return this.cache[name];
+    }
+}

package/node_modules/@web-atoms/entity/src/models/IPagedList.ts

@@ -0,0 +1,4 @@
+export default interface IPagedList<T> {
+    items: T[];
+    total: number;
+}

package/node_modules/@web-atoms/entity/src/models/Queue.ts

@@ -0,0 +1,34 @@
+
+export default class Queue<T> {
+
+    head = 0;
+    tail = 0;
+
+    store: Map<any,any> = new Map();
+
+    peek() {
+        return this.store[this.head];
+    }
+
+    public enqueue(item: T) {
+        this.store[this.tail] = item;
+        this.tail++;
+    }
+
+    public dequeue() {
+        const { head, tail } = this;
+        const size = tail - head;
+        if (size <= 0) {
+            return void 0;
+        }            
+        const item = this.store[head];
+        this.store.delete(head);
+        this.head++;
+        if (this.head === this.tail) {
+            this.head = 0;
+            this.tail = 0;
+        }
+        return item;
+    }
+
+}

package/node_modules/@web-atoms/entity/src/models/TaskManager.ts

@@ -0,0 +1,53 @@
+import Queue from "./Queue";
+
+export default class TaskManager {
+
+    public rateLimit = 10;
+
+    private running: Set<any> = new Set();
+
+    private waiting: Queue<{ resolve, reject, fx }> = new Queue();
+
+    protected run<TR>(fx: (... a: any[]) => Promise<TR>): Promise<TR> {
+
+        const pr = new Promise((resolve, reject) => {
+            this.waiting.enqueue({ resolve, reject, fx });
+        });
+
+        this.processQueue();
+
+        return pr as Promise<TR>;
+    }
+
+    protected processQueue() {
+        for(;;) {
+            if (this.running.size >= this.rateLimit) {
+                return;
+            }
+
+            const t = this.waiting.dequeue();
+            if (!t) {
+                return;
+            }
+
+            const { fx, resolve, reject } = t;
+
+            this.running.add(fx);
+
+            fx().then(
+                (r) => {
+                    this.running.delete(fx);
+                    setTimeout(() => this.processQueue(), 1);
+                    resolve(r);
+                },
+                (e) => {
+                    this.running.delete(fx);
+                    setTimeout(() => this.processQueue(), 1);
+                    reject(e);
+                }
+            );
+
+        }
+    }
+
+}

package/node_modules/@web-atoms/entity/src/models/cloneSource.ts

@@ -0,0 +1,2 @@
+const cloneSource = Symbol("cloneSource");
+export default cloneSource;