@entity-access/entity-access 1.0.45 → 1.0.47

package/src/eternity/EternityStorage.ts

@@ -0,0 +1,180 @@
+import Column from "../decorators/Column.js";
+import Index from "../decorators/Index.js";
+import Table from "../decorators/Table.js";
+import Inject, { RegisterScoped, RegisterSingleton, ServiceProvider } from "../di/di.js";
+import { BaseDriver } from "../drivers/base/BaseDriver.js";
+import EntityContext from "../model/EntityContext.js";
+import DateTime from "../types/DateTime.js";
+import WorkflowClock from "./WorkflowClock.js";
+
+@Table("Workflows")
+@Index({
+    name: "IX_Workflows_Group",
+    columns: [{ name: (x) => x.group, descending: false }],
+    filter: (x) => x.group !== null
+})
+@Index({
+    name: "IX_Workflows_ETA",
+    columns: [{ name: (x) => x.eta, descending: false }],
+    filter: (x) => x.isWorkflow === true
+})
+export class WorkflowStorage {
+
+    @Column({ dataType: "Char", length: 400, key: true })
+    public id: string;
+
+    @Column({ dataType: "Boolean" })
+    public isWorkflow: boolean;
+
+    @Column({ dataType: "Char", nullable: true })
+    public name: string;
+
+    @Column({ dataType: "Char", length: 200, nullable: true })
+    public group: string;
+
+    @Column({ dataType: "Char"})
+    public input: string;
+
+    @Column({ dataType: "Char", nullable: true})
+    public output: string;
+
+    @Column({ })
+    public eta: DateTime;
+
+    @Column({ })
+    public queued: DateTime;
+
+    @Column({ })
+    public updated: DateTime;
+
+    @Column({ dataType: "Int", default: "0"})
+    public priority: number;
+
+    @Column({ nullable: true })
+    public lockedTTL: DateTime;
+
+    @Column({ dataType: "AsciiChar", length: 10})
+    public state: "queued" | "failed" | "done";
+
+    @Column({ dataType: "Char", nullable: true})
+    public error: string;
+
+    @Column({ dataType: "Char", nullable: true})
+    public extra: string;
+
+    @Column({ dataType: "Char", length: 200 , nullable: true})
+    public parentID: string;
+
+    @Column({ dataType: "Char", length: 200 , nullable: true})
+    public lastID: string;
+}
+
+@RegisterScoped
+class WorkflowContext extends EntityContext {
+
+    public workflows = this.model.register(WorkflowStorage);
+
+    verifyFilters: boolean = false;
+
+    raiseEvents: boolean = false;
+
+}
+
+@RegisterSingleton
+export default class EternityStorage {
+
+    constructor(
+        @Inject
+        private driver: BaseDriver,
+        @Inject
+        public readonly clock: WorkflowClock
+    ) {
+
+    }
+
+    async get(id: string, input?) {
+        const db = new WorkflowContext(this.driver);
+        const r = await db.workflows.where({ id }, (p) => (x) => x.id === p.id && x.isWorkflow === true).first();
+        if (r !== null) {
+            return {
+                updated: r.updated,
+                eta: r.eta,
+                queued: r.queued,
+                state: r.state,
+                output: r.output,
+                error: r.error
+            };
+        }
+        return null;
+    }
+
+    async delete(id) {
+        const db = new WorkflowContext(this.driver);
+        const children = await db.workflows.where({ id}, (p) => (x) => x.parentID === p.id)
+            .limit(100)
+            .toArray();
+        for (const iterator of children) {
+            db.workflows.delete(iterator);
+        }
+        await db.saveChanges();
+        if (children.length === 100) {
+            return;
+        }
+
+        const w = await db.workflows.where({ id}, (p) => (x) => x.id === p.id).first();
+        if (!w) {
+            return;
+        }
+        db.workflows.delete(w);
+        await db.saveChanges();
+    }
+
+    async save(state: Partial<WorkflowStorage>) {
+        const db = new WorkflowContext(this.driver);
+        await this.driver.runInTransaction(async () => {
+            let w = await db.workflows.where(state, (p) => (x) => x.id === p.id).first();
+            if (!w) {
+                w = db.workflows.add(state);
+            }
+
+            for (const key in state) {
+                if (Object.prototype.hasOwnProperty.call(state, key)) {
+                    const element = state[key];
+                    w[key] = element;
+                }
+            }
+
+            w.state ||= "queued";
+            await db.saveChanges();
+        });
+    }
+
+    async dequeue(signal?: AbortSignal) {
+        const db = new WorkflowContext(this.driver);
+        const now = this.clock.utcNow;
+        const lockedTTL = now.addMinutes(1);
+        return this.driver.runInTransaction(async () => {
+            const list = await db.workflows
+                .where({now}, (p) => (x) => x.eta <= p.now
+                    && (x.lockedTTL === null || x.lockedTTL <= p.now)
+                    && x.isWorkflow === true)
+                .orderBy({}, (p) => (x) => x.eta)
+                .thenBy({}, (p) => (x) => x.priority)
+                .limit(20)
+                .withSignal(signal)
+                .toArray();
+            for (const iterator of list) {
+                iterator.lockedTTL = lockedTTL;
+            }
+            await db.saveChanges(signal);
+            return list;
+        });
+    }
+
+    async seed() {
+        const db = new WorkflowContext(this.driver);
+        await db.driver.ensureDatabase();
+        await db.driver.automaticMigrations().migrate(db);
+    }
+
+}

package/src/eternity/Workflow.ts

@@ -0,0 +1,55 @@
+import Inject from "../di/di.js";
+import DateTime from "../types/DateTime.js";
+import TimeSpan from "../types/TimeSpan.js";
+import EternityContext from "./EternityContext.js";
+import { WorkflowRegistry } from "./WorkflowRegistry.js";
+
+
+export function Activity(target, key) {
+    WorkflowRegistry.register(target.constructor, key);
+}
+
+export function UniqueActivity(target, key) {
+    WorkflowRegistry.register(target.constructor, key, true);
+}
+
+
+export default abstract class Workflow<TIn = any, TOut = any> {
+
+    /**
+     * If specified, all workflows in same sequence
+     * will executed sequentially in a single worker node
+     */
+    public readonly sequence: string;
+
+    public readonly input: TIn;
+
+    public readonly id: string;
+
+    public readonly eta: DateTime;
+
+    public readonly currentTime: DateTime;
+
+    public preserveTime: TimeSpan = TimeSpan.fromMinutes(5);
+
+    public failedPreserveTime: TimeSpan = TimeSpan.fromDays(1);
+
+    @Inject
+    protected context: EternityContext;
+
+    constructor(p: Partial<Workflow>) {
+        Object.setPrototypeOf(p, new.target.prototype);
+        return p as Workflow;
+    }
+
+    public abstract run(): Promise<TOut>;
+
+    public delay(ts: TimeSpan) {
+        return Promise.resolve("");
+    }
+
+    public waitForExternalEvent(ts: TimeSpan, ... names: string[]) {
+        // do nothing...
+        return Promise.resolve("");
+    }
+}

package/src/eternity/WorkflowClock.ts

@@ -0,0 +1,10 @@
+import { RegisterSingleton } from "../di/di.js";
+import DateTime from "../types/DateTime.js";
+
+@RegisterSingleton
+export default class WorkflowClock {
+
+    public get utcNow() {
+        return DateTime.utcNow;
+    }
+}

package/src/eternity/WorkflowRegistry.ts

@@ -0,0 +1,34 @@
+import { IClassOf } from "../decorators/IClassOf.js";
+import type Workflow from "./Workflow.js";
+
+export interface IWorkflowSchema {
+    name: string;
+    type: IClassOf<Workflow>;
+    activities: string[];
+    uniqueActivities: string[];
+}
+
+// const schema: Map<any,IWorkflowSchema> = new Map();
+const schemaByName: Map<string,IWorkflowSchema> = new Map();
+
+export const WorkflowRegistry = {
+    register(target: IClassOf<any>, key, unique = false) {
+        let methods = schemaByName.get(target.name);
+        if (!methods) {
+            methods = { name: target.name, type: target, activities: ["delay", "waitForExternalEvent"], uniqueActivities: [] };
+            schemaByName.set(target.name, methods);
+        }
+        if (key) {
+            if (unique) {
+                methods.uniqueActivities.push(key);
+            } else {
+                methods.activities.push(key);
+            }
+        }
+        return methods;
+    },
+
+    getByName(name: string) {
+        return schemaByName.get(name);
+    }
+};

package/src/migrations/Migrations.ts

@@ -24,6 +24,8 @@ export default abstract class Migrations {
     async migrateIndexInternal(context: EntityContext, index: IIndex, type: EntityType) {
         // parse filter... pending...
 
+        index = { ... index };
+
         if (index.filter && typeof index.filter !== "string") {
             // parse..
             const source = context.query(type.typeClass) as EntityQuery<any>;

package/src/model/EntityContext.ts

@@ -35,7 +35,7 @@ export default class EntityContext {
         @Inject
         private events?: ContextEvents,
         @Inject
-        private logger?: Logger
+        public readonly logger?: Logger
     ) {
         this.raiseEvents = !!events;
     }
@@ -159,7 +159,8 @@ export default class EntityContext {
     }
 
     protected async saveChangesWithoutEvents(signal: AbortSignal) {
-        for (const iterator of this.changeSet.entries) {
+        const copy = [].concat(this.changeSet.entries);
+        for (const iterator of copy) {
             switch (iterator.status) {
                 case "inserted":
                     const insert = this.driver.createInsertExpression(iterator.type, iterator.entity);

package/src/model/EntityQuery.ts

@@ -69,9 +69,8 @@ export default class EntityQuery<T = any>
     }
 
     async *enumerate(): AsyncGenerator<T, any, unknown> {
-        const logger = ServiceProvider.resolve(this.context, Logger);
         const scope = new DisposableScope();
-        const session = logger.newSession();
+        const session = this.context.logger?.newSession() ?? Logger.nullLogger;
         let query: { text: string, values: any[]};
         try {
             scope.register(session);

package/src/query/ast/DebugStringVisitor.ts

@@ -1,4 +1,4 @@
-import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import Visitor from "./Visitor.js";
 
 const isBinary = (type) => /^(BinaryExpression|CoalesceExpression)$/.test(type);
@@ -169,7 +169,16 @@ export default class DebugStringVisitor extends Visitor<string> {
         return "UPDATE";
     }
 
+    visitNotExists(e: NotExits): string {
+        return ` NOT EXISTS ${this.visit(e.target)}`;
+    }
+
+    visitUnionAllStatement(e: UnionAllStatement): string {
+        return e.queries.map((x) => this.visit(x)).join("\nUNION ALL\n");
+    }
+
     private visitArray(e: Expression[], separator = ", ") {
         return e.map((x) => this.visit(x)).join(separator);
     }
+
 }

package/src/query/ast/ExpressionToSql.ts

@@ -2,7 +2,7 @@ import QueryCompiler from "../../compiler/QueryCompiler.js";
 import EntityType from "../../entity-query/EntityType.js";
 import EntityQuery from "../../model/EntityQuery.js";
 import { filteredSymbol } from "../../model/events/EntityEvents.js";
-import { BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import { ITextQuery, QueryParameter, prepare, prepareJoin } from "./IStringTransformer.js";
 import ParameterScope from "./ParameterScope.js";
 import Visitor from "./Visitor.js";
@@ -126,7 +126,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
     }
 
     visitBooleanLiteral( { value }: BooleanLiteral): ITextQuery {
-        return [ () => value ? "1" : "0" ];
+        return [ value ? " true ": " false "];
     }
 
     visitTemplateLiteral(e: TemplateLiteral): ITextQuery {
@@ -284,6 +284,10 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         return prepare `${this.visit(target)}.${this.visit(property)}`;
     }
 
+    visitNotExists(e: NotExits): ITextQuery {
+        return [" NOT EXISTS ", this.visit(e.target) ];
+    }
+
     visitNullExpression(e: NullExpression): ITextQuery {
         return ["NULL"];
     }
@@ -298,7 +302,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             : this.visit(e.right);
 
         if ((e.right as ExpressionType).type === "NullExpression") {
-            if (e.operator === "===" || e.operator === "==") {
+            if (e.operator === "===" || e.operator === "==" || e.operator === "=") {
                 return prepare `${left} IS NULL`;
             }
             if (e.operator === "!==" || e.operator === "!=" || e.operator === "<>") {
@@ -306,7 +310,7 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
             }
         }
         if ((e.left as ExpressionType).type === "NullExpression") {
-            if (e.operator === "===" || e.operator === "==") {
+            if (e.operator === "===" || e.operator === "==" || e.operator === "=") {
                 return prepare `${right} IS NULL`;
             }
             if (e.operator === "!==" || e.operator === "!=" || e.operator === "<>") {
@@ -411,6 +415,20 @@ export default class ExpressionToSql extends Visitor<ITextQuery> {
         return prepare `EXISTS (${this.visit(e.target)})`;
     }
 
+    visitUnionAllStatement(e: UnionAllStatement): ITextQuery {
+        const all: ITextQuery = [];
+        let first = true;
+        for (const iterator of e.queries) {
+            all.push(this.visit(iterator));
+            if (first) {
+                first = false;
+                continue;
+            }
+            all.push(" UNION ALL ");
+        }
+        return all;
+    }
+
     /**
      * This will also create and replace joins if query is provided.
      * @param x MemberExpression

package/src/query/ast/Expressions.ts

@@ -124,7 +124,7 @@ export abstract class Expression {
         return copy;
     }
 
-    readonly type: never | string;
+    readonly type: ExpressionType["type"];
 
 }
 
@@ -133,10 +133,10 @@ export class ArrayExpression extends Expression {
     elements: Expression[];
 }
 
-export class PartialExpression extends Expression {
-    readonly type = "PartialExpression";
-    query: ITextQuery;
-}
+// export class PartialExpression extends Expression {
+//     readonly type = "PartialExpression";
+//     query: ITextQuery;
+// }
 
 export class BinaryExpression extends Expression {
 
@@ -166,6 +166,11 @@ export class OrderByExpression extends Expression {
     descending: boolean;
 }
 
+export class NotExits extends Expression {
+    readonly type = "NotExists";
+    target: Expression;
+}
+
 export class ExistsExpression extends Expression {
     readonly type = "ExistsExpression";
     target: Expression;
@@ -371,6 +376,11 @@ export class UpdateStatement extends Expression {
 
 }
 
+export class UnionAllStatement extends Expression {
+    readonly type = "UnionAllStatement";
+    queries: Expression[];
+}
+
 export class DeleteStatement extends Expression {
     readonly type = "DeleteStatement";
     table: TableLiteral | QuotedLiteral;
@@ -407,5 +417,7 @@ export type ExpressionType =
     NewObjectExpression |
     ParameterExpression |
     ArrayExpression |
+    NotExits |
+    UnionAllStatement |
     TemplateElement
 ;

package/src/query/ast/Visitor.ts

@@ -1,5 +1,5 @@
 import { NotSupportedError } from "../parser/NotSupportedError.js";
-import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrayExpression, ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, ExpressionType, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 
 
 export default abstract class Visitor<T = any> {
@@ -69,10 +69,20 @@ export default abstract class Visitor<T = any> {
                 return this.visitParameterExpression(e);
             case "ArrayExpression":
                 return this.visitArrayExpression(e);
+            case "NotExists":
+                return this.visitNotExists(e);
+            case "UnionAllStatement":
+                return this.visitUnionAllStatement(e);
         }
         const c: never = e;
         throw new Error(`${e1.type} Not implemented`);
     }
+    visitUnionAllStatement(e: UnionAllStatement): T {
+        throw new NotSupportedError("Union All");
+    }
+    visitNotExists(e: NotExits): T {
+        throw new NotSupportedError("Not Exists");
+    }
     visitArrayExpression(e: ArrayExpression): T {
         throw new NotSupportedError("Array Expression");
     }

package/src/query/parser/ArrowToExpression.ts

@@ -1,5 +1,5 @@
 import { parseExpression } from "@babel/parser";
-import { ArrowFunctionExpression, BinaryExpression, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, ParameterExpression, QuotedLiteral, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
+import { ArrowFunctionExpression, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, Expression, ExpressionAs, Identifier, MemberExpression, NewObjectExpression, NullExpression, NumberLiteral, ParameterExpression, QuotedLiteral, StringLiteral, TemplateLiteral } from "../ast/Expressions.js";
 import { BabelVisitor } from "./BabelVisitor.js";
 import * as bpe from "@babel/types";
 import Restructure from "./Restructure.js";
@@ -85,7 +85,7 @@ export default class ArrowToExpression extends BabelVisitor<Expression> {
     }
 
     visitBooleanLiteral({ value }: bpe.BooleanLiteral) {
-        return Constant.create({ value });
+        return BooleanLiteral.create({ value });
     }
 
     visitDecimalLiteral( { value }: bpe.DecimalLiteral) {

package/src/tests/eternity/eternity-tests.ts

@@ -0,0 +1,108 @@
+import assert from "assert";
+import Inject, { Register, RegisterSingleton, ServiceProvider } from "../../di/di.js";
+import EternityContext from "../../eternity/EternityContext.js";
+import Workflow, { Activity } from "../../eternity/Workflow.js";
+import WorkflowClock from "../../eternity/WorkflowClock.js";
+import DateTime from "../../types/DateTime.js";
+import { TestConfig } from "../TestConfig.js";
+import { BaseDriver } from "../../drivers/base/BaseDriver.js";
+import EternityStorage from "../../eternity/EternityStorage.js";
+import TimeSpan from "../../types/TimeSpan.js";
+import sleep from "../../common/sleep.js";
+
+class MockClock extends WorkflowClock {
+
+    public get utcNow(): DateTime {
+        return this.time;
+    }
+
+    public set utcNow(v: DateTime) {
+        this.time = v;
+    }
+
+    private time: DateTime = DateTime.utcNow;
+
+    public add(ts: TimeSpan) {
+        this.time = this.time.add(ts);
+        return this;
+    }
+}
+
+@RegisterSingleton
+class Mailer {
+
+    public items: any[] = [];
+}
+
+class SendWorkflow extends Workflow<string, string> {
+
+    public async run(): Promise<any> {
+
+        await this.delay(TimeSpan.fromHours(1));
+
+        await this.sendMail("a", "b", "c");
+        return "1";
+    }
+
+    @Activity
+    public async sendMail(
+        from: string,
+        to: string,
+        message: string,
+        @Inject logger?: Mailer) {
+        await sleep(10);
+        logger.items.push({ from, to, message });
+    }
+
+}
+
+export default async function (this: TestConfig) {
+
+    const mockClock = new MockClock();
+    const mailer = new Mailer();
+
+    const scope = new ServiceProvider();
+    scope.add(WorkflowClock, mockClock);
+    scope.add(BaseDriver, this.driver);
+    const storage = new EternityStorage(this.driver, mockClock);
+    await storage.seed();
+    scope.add(Mailer, mailer);
+    scope.add(EternityStorage, storage);
+
+    const c = new EternityContext(storage);
+    scope.add(EternityContext, c);
+
+    // this is an important step
+    c.register(SendWorkflow);
+
+    const id = await c.queue(SendWorkflow, "a");
+
+    mockClock.add(TimeSpan.fromSeconds(15));
+
+    await c.processQueueOnce();
+
+    mockClock.add(TimeSpan.fromSeconds(15));
+
+    await c.processQueueOnce();
+
+    assert.equal(0, mailer.items.length);
+
+    mockClock.add(TimeSpan.fromHours(1));
+
+    await c.processQueueOnce();
+
+    assert.equal(1, mailer.items.length);
+
+    let r = await c.get(SendWorkflow, id);
+    assert.equal("1", r.output);
+
+    mockClock.add(TimeSpan.fromDays(2));
+
+    await c.processQueueOnce();
+
+    r = await c.get(SendWorkflow, id);
+    assert.strictEqual(null, r);
+
+    // throw new Error("Preserve");
+
+}

package/src/tests/security/tests/place-order.ts

@@ -27,7 +27,9 @@ export default async function(this: TestConfig) {
 }
 
 async function getNewOrders(this: TestConfig) {
-    const scope = ServiceProvider.global.createScope();
+    const global = new ServiceProvider();
+    global.add(BaseDriver, this.driver);
+    const scope = global.createScope();
     try {
         const user = new UserInfo();
         user.userID = 2;
@@ -49,7 +51,9 @@ async function getNewOrders(this: TestConfig) {
 }
 
 async function addNewOrder(this: TestConfig, customer: User, userID?) {
-    const scope = ServiceProvider.global.createScope();
+    const global = new ServiceProvider();
+    global.add(BaseDriver, this.driver);
+    const scope = global.createScope();
     try {
         const user = new UserInfo();
         user.userID = userID ?? customer.userID;