@entity-access/entity-access 1.0.1

package/src/migrations/sql-server/SqlServerMigrations.ts

@@ -0,0 +1,60 @@
+import { IColumn } from "../../decorators/IColumn.js";
+import Migrations from "../Migrations.js";
+
+export default abstract class SqlServerMigrations extends Migrations {
+
+    protected getColumnDefinition(iterator: IColumn) {
+        if (iterator.dataType === "Decimal") {
+            if (iterator.precision && iterator.scale) {
+                return `decimal (${iterator.precision}, ${iterator.scale})`;
+            }
+            return `decimal (18,2)`;
+        }
+        const type = this.getColumnType(iterator);
+        if (iterator.length) {
+            return `${type} (${iterator.length})`;
+        }
+        return type;
+    }
+
+    protected getColumnType(iterator: IColumn) {
+        switch(iterator.dataType) {
+            case "BigInt":
+                return "bigint";
+            case "AsciiChar":
+                if (!iterator.length) {
+                    return "varchar(max)";
+                }
+                return "varchar";
+            case "Char":
+                if (!iterator.length) {
+                    return "nvarchar(max)";
+                }
+                return "nvarchar";
+            case "DateTime":
+                return "DateTime2";
+            case "DateTimeOffset":
+                return "DateTimeOffset";
+            case "Double":
+                return "float";
+            case "Float":
+                return "real";
+            case "Int":
+                return "int";
+            case "Boolean":
+                return "bit";
+            case "ByteArray":
+                return "varbinary";
+            case "Decimal":
+                return "decimal";
+            case "JSON":
+                return "json";
+            case "JSONB":
+                return "jsonb";
+            case "UUID":
+                return "UniqueIdentifier";
+        }
+        const a: never = iterator.dataType;
+        throw new Error("Not Defined");
+    }
+}

package/src/model/ChangeEntry.ts

@@ -0,0 +1,154 @@
+import { IColumn } from "../decorators/IColumn.js";
+import EntityType from "../entity-query/EntityType.js";
+import type ChangeSet from "./ChangeSet.js";
+import { privateUpdateEntry } from "./ChangeSet.js";
+
+export interface IChanges {
+    type: EntityType;
+    entity: any;
+    order: number;
+    original: any;
+    status: "detached" | "attached" | "inserted" | "modified" | "deleted" | "unchanged";
+}
+
+export interface IChange {
+    column: IColumn;
+    oldValue: any;
+    newValue: any;
+}
+
+export default class ChangeEntry implements IChanges {
+
+    type: EntityType;
+    entity: any;
+    order: number;
+    original: any;
+    status: "detached" | "attached" | "inserted" | "modified" | "deleted" | "unchanged";
+
+    modified: Map<IColumn, IChange>;
+
+    changeSet: ChangeSet;
+
+    private pending: (() => void)[];
+
+    constructor(p: IChanges, changeSet: ChangeSet) {
+        Object.setPrototypeOf(p, ChangeEntry.prototype);
+        const ce = p as ChangeEntry;
+        ce.changeSet = changeSet;
+        ce.pending = [];
+        ce.modified = new Map();
+        return ce;
+    }
+
+    public detect() {
+
+        const { type: { columns }, entity, original } = this;
+
+        if (original === void 0) {
+            this.status = "inserted";
+            this.detectDependencies();
+            return;
+        }
+
+        this.detectDependencies();
+
+        for (const iterator of columns) {
+            const oldValue = original[iterator.columnName];
+            const newValue = entity[iterator.name];
+            if (entity[iterator.name] !== original[iterator.columnName]) {
+                let modifiedEntry = this.modified.get(iterator);
+                if (!modifiedEntry) {
+                    modifiedEntry = { column: iterator, oldValue, newValue };
+                    this.modified.set(iterator, modifiedEntry);
+                }
+            }
+        }
+
+
+        if (this.modified.size > 0) {
+            this.status = "modified";
+        } else {
+            this.status = "unchanged";
+        }
+    }
+
+    public apply(dbValues) {
+        // apply values to main entity
+        // set status to unchanged
+
+        // we will only apply the columns defined
+        if (dbValues !== void 0) {
+            for (const iterator of this.type.columns) {
+                const dbValue = dbValues[iterator.columnName];
+                if (dbValue !== void 0) {
+                    this.entity[iterator.name] = dbValues[iterator.columnName];
+                }
+            }
+        }
+
+        for (const iterator of this.pending) {
+            iterator();
+        }
+
+        // we will set the identity key
+        this.changeSet[privateUpdateEntry](this);
+
+        this.pending.length = 0;
+        this.original = { ... this.entity };
+        this.status = "unchanged";
+        this.modified.clear();
+    }
+
+    detectDependencies() {
+        const { type: { relations }, entity } = this;
+        // for parent relations.. check if related key is set or not...
+        for (const iterator of relations) {
+            if (iterator.isCollection) {
+                continue;
+            }
+
+            // get related entry..
+            const related = entity[iterator.name];
+            if (!related) {
+                continue;
+            }
+
+            // if related has key defined.. set it...
+            const rKey = iterator.relatedEntity.keys[0];
+
+            const relatedChanges = this.changeSet.getEntry(related);
+
+            const keyValue = related[rKey.name];
+            if (keyValue === void 0) {
+                this.order++;
+                const fk = iterator;
+                relatedChanges.pending.push(() => {
+                    this.entity[fk.fkColumn.name] = related[rKey.name];
+                });
+                this.modified.set(iterator, { column: iterator.fkColumn, oldValue: void 0, newValue: void 0});
+                continue;
+            }
+
+            this.entity[iterator.fkColumn.name] = related[rKey.name];
+        }
+    }
+
+    setupInverseProperties() {
+        for (const iterator of this.type.relations) {
+            if (!iterator.isCollection) {
+                continue;
+            }
+            const related = this.entity[iterator.name];
+            if (related === void 0) {
+                continue;
+            }
+            if (Array.isArray(related)) {
+                for (const r of related) {
+                    r[iterator.relatedName] = this.entity;
+                }
+                continue;
+            }
+            related[iterator.relatedName] = this.entity;
+        }
+    }
+}

package/src/model/ChangeSet.ts

@@ -0,0 +1,88 @@
+import type EntityContext from "./EntityContext.js";
+import SchemaRegistry from "../decorators/SchemaRegistry.js";
+import ChangeEntry from "./ChangeEntry.js";
+import { IRecord } from "../drivers/base/BaseDriver.js";
+import IdentityService from "./IdentityService.js";
+
+const entrySymbol = Symbol("entry");
+
+const identitySymbol = Symbol("identity");
+
+const getEntityByIdentity = Symbol("getEntityByIdentity");
+
+export const privateUpdateEntry = Symbol("updateEntry");
+
+export default class ChangeSet {
+
+    public readonly entries: ChangeEntry[] = [];
+
+    private entryMap: Map<any, ChangeEntry> = new Map();
+
+    /**
+     * This will provide new entity for same key
+     */
+    private identityMap: Map<string,ChangeEntry> = new Map();
+
+    private nextId = 1;
+
+    constructor(private context: EntityContext) {
+
+    }
+
+    [privateUpdateEntry](entry: ChangeEntry) {
+        const jsonKey = IdentityService.getIdentity(entry.entity);
+        if (jsonKey) {
+            this.identityMap.set(jsonKey, entry.entity);
+        }
+    }
+
+    public getEntry(entity, original = void 0): ChangeEntry {
+        let entry = this.entryMap.get(entity);
+        if (entry) {
+            return entry;
+        }
+        const type = SchemaRegistry.model(Object.getPrototypeOf(entity).constructor);
+        const jsonKey = IdentityService.getIdentity(entity);
+        if (jsonKey) {
+            const existing = this.identityMap.get(jsonKey);
+            if (existing) {
+                entity = existing;
+                entry = this.entryMap.get(entity);
+                if (entry) {
+                    return entry;
+                }
+            } else {
+                this.identityMap.set(jsonKey, entity);
+            }
+        }
+        entry = new ChangeEntry({
+            type,
+            entity,
+            order: 0,
+            original: original ? { ... original } : void 0,
+            status: "unchanged"
+        }, this);
+        entity[entrySymbol] = entry;
+        this.entries.push(entry);
+        this.entryMap.set(entity, entry);
+        return entry;
+    }
+
+    /**
+     * Detect changes will detect and sort the entries as they should be inserted.
+     */
+    public detectChanges() {
+
+        for (const iterator of this.entries) {
+            iterator.setupInverseProperties();
+        }
+
+        for (const iterator of this.entries) {
+            iterator.detect();
+        }
+
+        this.entries.sort((a, b) => a.order - b.order);
+
+    }
+
+}

package/src/model/EntityContext.ts

@@ -0,0 +1,48 @@
+import { BaseDriver } from "../drivers/base/BaseDriver.js";
+import ChangeSet from "./ChangeSet.js";
+import EntityModel from "./EntityModel.js";
+import { Expression } from "../query/ast/Expressions.js";
+import QueryCompiler from "../compiler/QueryCompiler.js";
+
+export default class EntityContext {
+
+    public readonly model = new EntityModel(this);
+    public readonly changeSet = new ChangeSet(this);
+
+    constructor(
+        public driver: BaseDriver
+    ) {
+
+    }
+
+    public async saveChanges() {
+
+        this.changeSet.detectChanges();
+
+        await this.driver.runInTransaction(async () => {
+            for (const iterator of this.changeSet.entries) {
+                switch(iterator.status) {
+                    case "inserted":
+                        const insert  = this.driver.createInsertExpression(iterator.type, iterator.entity);
+                        const r = await this.executeExpression(insert);
+                        iterator.apply(r);
+                        break;
+                    case "modified":
+                        if (iterator.modified.size > 0) {
+                            const update = this.driver.createUpdateExpression(iterator);
+                            await this.executeExpression(update);
+                        }
+                        iterator.apply({});
+                        break;
+                }
+            }
+        });
+    }
+
+    private async executeExpression(expression: Expression) {
+        const { text, values } = this.driver.compiler.compileExpression(expression);
+        const r = await this.driver.executeQuery({ text, values });
+        return r.rows[0];
+    }
+
+}

package/src/model/EntityModel.ts

@@ -0,0 +1,27 @@
+import type EntityContext from "./EntityContext.js";
+import { IClassOf } from "../decorators/IClassOf.js";
+import SchemaRegistry from "../decorators/SchemaRegistry.js";
+import EntityQuery from "./EntityQuery.js";
+import { Expression } from "@babel/types";
+import { EntitySource } from "./EntitySource.js";
+
+
+
+export default class EntityModel {
+
+    public entities: Map<IClassOf<any>, EntitySource> = new Map();
+
+    constructor(private context: EntityContext) {
+    }
+
+    register<T>(type: IClassOf<T>) {
+        let source = this.entities.get(type);
+        if (!source) {
+            const model = SchemaRegistry.model(type);
+            source = new EntitySource(model, this.context);
+            this.entities.set(type, source);
+        }
+        return source as EntitySource<T>;
+    }
+
+}

package/src/model/EntityQuery.ts

@@ -0,0 +1,152 @@
+import { BinaryExpression, CallExpression, Expression, ExpressionAs, Identifier, OrderByExpression, QuotedLiteral, SelectStatement, TableSource } from "../query/ast/Expressions.js";
+import { EntitySource } from "./EntitySource.js";
+import { IOrderedEntityQuery, IEntityQuery, ILambdaExpression } from "./IFilterWithParameter.js";
+import { SourceExpression } from "./SourceExpression.js";
+
+export default class EntityQuery<T = any>
+    implements IOrderedEntityQuery<T>, IEntityQuery<T> {
+    constructor (public readonly source: SourceExpression) {
+    }
+
+    withSignal(signal: AbortSignal): any {
+        const source = this.source.copy();
+        source.signal = signal;
+        return new EntityQuery(source);
+    }
+
+    thenBy(parameters: any, fx: any): any {
+        return this.orderBy(parameters, fx);
+    }
+    thenByDescending(parameters: any, fx: any) {
+        return this.orderByDescending(parameters, fx);
+    }
+    where<P>(parameters: P, fx: (p: P) => (x: T) => boolean): any {
+
+        const source = this.source.copy();
+        const { select } = source;
+        const exp = this.source.context.driver.compiler.compileToExpression(source, parameters, fx);
+        if(!select.where) {
+            select.where = exp;
+        } else {
+            select.where = BinaryExpression.create({
+                left: select.where,
+                operator: "AND",
+                right: exp
+            });
+        }
+        return new EntityQuery(source);
+    }
+
+    async toArray(): Promise<T[]> {
+        const results: T[] = [];
+        for await (const iterator of this.enumerate()) {
+            results.push(iterator);
+        }
+        return results;
+    }
+
+    async *enumerate(): AsyncGenerator<T, any, unknown> {
+        const type = this.source.model?.typeClass;
+        const signal = this.source.signal;
+        const query = this.source.context.driver.compiler.compileExpression(this.source.select);
+        const reader = await this.source.context.driver.executeReader(query, signal);
+        try {
+            for await (const iterator of reader.next(10, signal)) {
+                if (type) {
+                    Object.setPrototypeOf(iterator, type.prototype);
+                    // set identity...
+                    const entry = this.source.context.changeSet.getEntry(iterator, iterator);
+                    yield entry.entity;
+                    continue;
+                }
+                yield iterator as T;
+            }
+        } finally {
+            await reader.dispose();
+        }
+    }
+
+    async firstOrFail(): Promise<T> {
+        for await(const iterator of this.limit(1).enumerate()) {
+            return iterator;
+        }
+        throw new Error(`No records found for ${this.source.model?.name || "Table"}`);
+    }
+
+    async first(): Promise<T> {
+        for await(const iterator of this.limit(1).enumerate()) {
+            return iterator;
+        }
+        return null;
+    }
+    toQuery(): { text: string; values: any[]; } {
+        return this.source.context.driver.compiler.compileExpression(this.source.select);
+    }
+    orderBy(parameters: any, fx: any): any {
+        const source = this.source.copy();
+        const { select } = source;
+        const exp = this.source.context.driver.compiler.compileToExpression(source, parameters, fx as any);
+        select.orderBy ??= [];
+        select.orderBy.push(OrderByExpression.create({
+            target: exp
+        }));
+        return new EntityQuery(source);
+    }
+    orderByDescending(parameters: any, fx: any): any {
+        const source = this.source.copy();
+        const { select } = source;
+        const exp = this.source.context.driver.compiler.compileToExpression(source, parameters, fx as any);
+        select.orderBy ??= [];
+        select.orderBy.push(OrderByExpression.create({
+            target: exp,
+            descending: true
+        }));
+        return new EntityQuery(source);
+    }
+
+    limit(n: number): any {
+        const source = this.source.copy();
+        const { select } = source;
+        select.limit = n;
+        return new EntityQuery(source);
+    }
+
+    offset(n: number): any {
+        const source = this.source.copy();
+        const { select } = source;
+        select.offset = n;
+        return new EntityQuery(source);
+    }
+
+    async count(parameters?:any, fx?: any): Promise<number> {
+        if (parameters !== void 0) {
+            return this.where(parameters, fx).count();
+        }
+
+        const source = this.source.copy();
+        const { select } = source;
+
+        select.fields = [
+            ExpressionAs.create({
+                expression: CallExpression.create({
+                    callee: Identifier.create({ value: "COUNT"}),
+                    arguments: [ Identifier.create({ value: "*"})]
+                }),
+                alias: QuotedLiteral.create({ literal: "count" })
+            })
+        ];
+
+        const query = this.source.context.driver.compiler.compileExpression(select);
+        const reader = await this.source.context.driver.executeReader(query);
+
+        try {
+            for await (const iterator of reader.next()) {
+                return iterator.count as number;
+            }
+        } finally {
+            await reader.dispose();
+        }
+
+    }
+
+}

package/src/model/EntitySchema.ts

@@ -0,0 +1,21 @@
+export class EntityColumn {
+    constructor(
+        public readonly name: string,
+        public readonly columnName: string,
+        public readonly storageType: string
+    ) {
+
+    }
+}
+
+export default class EntitySchema {
+
+    constructor(
+        public readonly name: string,
+        public readonly table: string,
+        public readonly columns: EntityColumn[],
+        public readonly schema?: string,
+    ) {
+    }
+
+}

package/src/model/EntitySource.ts

@@ -0,0 +1,98 @@
+import type EntityContext from "./EntityContext.js";
+import type EntityType from "../entity-query/EntityType.js";
+import type { IEntityQuery, IFilterExpression } from "./IFilterWithParameter.js";
+import { BinaryExpression, Expression, ExpressionAs, QuotedLiteral, SelectStatement, TableLiteral } from "../query/ast/Expressions.js";
+import EntityQuery from "./EntityQuery.js";
+import TimedCache from "../common/cache/TimedCache.js";
+import { contextSymbol, modelSymbol } from "../common/symbols/symbols.js";
+import { SourceExpression } from "./SourceExpression.js";
+
+const modelCache = new TimedCache<any, SelectStatement>();
+
+export class EntitySource<T = any> {
+
+
+    public readonly filters: {
+        read?: () => IFilterExpression;
+        modify?: () => IFilterExpression;
+        delete?: () => IFilterExpression;
+        include?: () => IFilterExpression;
+    } = {};
+
+
+    get [modelSymbol]() {
+        return this.model;
+    }
+
+    get[contextSymbol]() {
+        return this.context;
+    }
+
+    private filter: Expression;
+
+    constructor(
+        private readonly model: EntityType,
+        private readonly context: EntityContext
+    ) {
+
+    }
+
+    public add(item: Partial<T>) {
+        const p = Object.getPrototypeOf(item).constructor;
+        if (!p || p === Object) {
+            Object.setPrototypeOf(item, this.model.typeClass.prototype);
+        }
+        const entry = this.context.changeSet.getEntry(item);
+        if (entry.status !== "detached" && entry.status !== "unchanged") {
+            throw new Error("Entity is already attached to the context");
+        }
+        entry.status = "inserted";
+        return item as T;
+    }
+
+    public all(): IEntityQuery<T> {
+        const { model, context } = this;
+        const select = modelCache.getOrCreate(`select-model-${this.model.name}`, () => this.generateModel());
+        return new EntityQuery<T>(SourceExpression.create({
+            alias: select.as.literal,
+            context,
+            model,
+            select
+        })) as IEntityQuery<T>;
+    }
+
+    public where<P>(...[parameter, fx]: IFilterExpression<P, T>) {
+        const { model, context } = this;
+        const select = modelCache.getOrCreate(`select-model-${this.model.name}`, () => this.generateModel());
+        return new EntityQuery<T>(SourceExpression.create({
+            alias: select.as.literal,
+            context,
+            model,
+            select
+        })).where(parameter, fx) as IEntityQuery<T>;
+    }
+
+    generateModel(): SelectStatement {
+        const source = this.model.fullyQualifiedName;
+        const as = QuotedLiteral.create({ literal: this.model.name[0] + "1" });
+        const fields = this.model.columns.map((c) => c.name !== c.columnName
+            ? ExpressionAs.create({
+                expression: QuotedLiteral.propertyChain(as.literal, c.columnName),
+                alias: QuotedLiteral.create({ literal: c.name })
+            })
+            : QuotedLiteral.propertyChain(as.literal, c.columnName));
+        return SelectStatement.create({
+            source,
+            as,
+            fields,
+        });
+    }
+
+    public toQuery() {
+        const filter = this.filter;
+        if(!filter) {
+            return "";
+        }
+        return this.context.driver.compiler.compileExpression(filter);
+    }
+}

package/src/model/IFilterWithParameter.ts

@@ -0,0 +1,38 @@
+
+export type IFilterWithParameter<P = any, T = any> = (p: P) => (x: T) => boolean;
+
+export type ILambdaExpression<P = any, T = any, TR = any> = [input: P, x: (p: P) => (s: T) => TR];
+
+export type IFilterExpression<P = any, T = any> = [input: P, x: (p: P) => (s: T) => boolean];
+
+export interface IBaseQuery<T> {
+    enumerate(): AsyncGenerator<T>;
+
+    firstOrFail(): Promise<T>;
+    first(): Promise<T>;
+
+    toArray(): Promise<T[]>;
+
+    toQuery(): { text: string, values: any[]};
+
+    limit<DT>(this: DT, limit: number): DT;
+    offset<DT>(this: DT, offset: number): DT;
+    where<P, DT>(this: DT, parameters: P, fx: (p: P) => (x: T) => boolean): DT;
+
+    count(): Promise<number>;
+    count<P>(parameters: P, fx: (p: P) => (x: T) => boolean): Promise<number>;
+
+    withSignal<DT>(this:DT, signal: AbortSignal): DT;
+}
+
+export interface IOrderedEntityQuery<T> extends IBaseQuery<T> {
+
+    thenBy<P>(parameters: P, fx: (p: P) => (x: T) => any);
+    thenByDescending<P>(parameters: P, fx: (p: P) => (x: T) => any);
+}
+
+export interface IEntityQuery<T> extends IBaseQuery<T> {
+
+    orderBy<P>(parameters: P, fx: (p: P) => (x: T) => any): IOrderedEntityQuery<T>;
+    orderByDescending<P>(parameters: P, fx: (p: P) => (x: T) => any): IOrderedEntityQuery<T>;
+}