@adviser/cement 0.5.5 → 0.5.7

package/ts/esm/evento.js

@@ -0,0 +1,155 @@
+import { AppContext } from "./app-context.js";
+import { Option } from "./option.js";
+import { ResolveOnce } from "./resolve-once.js";
+import { exception2Result, Result } from "./result.js";
+export const EventoResult = {
+    Continue: "continue",
+    Stop: "stop",
+};
+export { EventoOp };
+var EventoOp;
+(function (EventoOp) {
+    EventoOp["Push"] = "push";
+    EventoOp["Unshift"] = "unshift";
+    EventoOp["Position"] = "position";
+})(EventoOp || (EventoOp = {}));
+export { EventoType };
+var EventoType;
+(function (EventoType) {
+    EventoType["WildCard"] = "wildcard";
+    EventoType["Regular"] = "regular";
+})(EventoType || (EventoType = {}));
+function unregFunc(item, actions) {
+    return () => {
+        const index = actions.findIndex((x) => x.hash === item.hash);
+        if (index >= 0) {
+            actions.splice(index, 1);
+        }
+    };
+}
+export class Evento {
+    actions = [];
+    wildcards = [];
+    encoder;
+    constructor(encoder) {
+        this.encoder = encoder;
+    }
+    handlers() {
+        return {
+            actions: [...this.actions],
+            wildcards: [...this.wildcards],
+        };
+    }
+    push(...hdls) {
+        return this.register(...hdls.flat().map((handler) => {
+            return {
+                handler,
+                type: handler.type ?? EventoType.Regular,
+                op: EventoOp.Push,
+            };
+        }));
+    }
+    unshift(...hdls) {
+        return this.register(...hdls.flat().map((handler) => {
+            return {
+                handler: handler,
+                type: handler.type ?? EventoType.Regular,
+                op: EventoOp.Unshift,
+            };
+        }));
+    }
+    register(...hdls) {
+        return hdls.map((item) => {
+            const handlers = item.type === EventoType.WildCard ? this.wildcards : this.actions;
+            const hasHandler = handlers.find((h) => h.hash === item.handler.hash);
+            if (hasHandler) {
+                return unregFunc(hasHandler, handlers);
+            }
+            switch (item.op) {
+                case EventoOp.Push:
+                    handlers.push(item.handler);
+                    return unregFunc(item.handler, handlers);
+                case EventoOp.Unshift:
+                    handlers.unshift(item.handler);
+                    return unregFunc(item.handler, handlers);
+                case EventoOp.Position:
+                    handlers.splice(item.idx, 0, item.handler);
+                    return unregFunc(item.handler, handlers);
+                default:
+                    throw new Error(`Unknown position`);
+            }
+        });
+    }
+    async trigger(ictx) {
+        return exception2Result(async () => {
+            const ctx = {
+                ...ictx,
+                encoder: ictx.encoder ?? this.encoder,
+                ctx: ictx.ctx ?? new AppContext(),
+            };
+            const results = [];
+            if (!ctx.enRequest) {
+                const rUnk = await this.encoder.encode(ctx.request);
+                if (rUnk.isErr()) {
+                    return Result.Err(rUnk);
+                }
+                const unk = rUnk.unwrap();
+                ctx.enRequest = unk;
+            }
+            const validateCtx = {
+                ...ctx,
+                enRequest: ctx.enRequest,
+                request: ctx.request,
+            };
+            const startOnce = new ResolveOnce();
+            for (const hdl of [...this.actions, "breakpoint", ...this.wildcards]) {
+                if (typeof hdl === "string") {
+                    if (results.length > 0) {
+                        break;
+                    }
+                    continue;
+                }
+                const rData = await Promise.resolve(hdl.validate ? hdl.validate(validateCtx) : Result.Ok(Option.Some(ctx.enRequest)));
+                if (rData.isErr()) {
+                    return Result.Err(rData);
+                }
+                const data = rData.Ok();
+                if (data.IsNone()) {
+                    continue;
+                }
+                const hdlCtx = {
+                    ...ctx,
+                    validated: data.Unwrap(),
+                    request: ctx.request,
+                    enRequest: ctx.enRequest,
+                };
+                if (ctx.send.start) {
+                    const rStart = await startOnce.once(() => ctx.send.start(hdlCtx).then((rv) => {
+                        if (rv.isErr()) {
+                            return Result.Err(rv);
+                        }
+                        return Result.Ok(hdlCtx);
+                    }));
+                    if (rStart.isErr()) {
+                        return Result.Err(rStart);
+                    }
+                }
+                const rHandle = await hdl.handle(hdlCtx);
+                if (rHandle.isErr()) {
+                    return Result.Err(rHandle);
+                }
+                results.push(hdl.hash);
+                if (rHandle.Ok() === EventoResult.Stop) {
+                    break;
+                }
+            }
+            if (ctx.send.done && startOnce.state === "processed" && startOnce.value) {
+                if (startOnce.value.isOk()) {
+                    await ctx.send.done(startOnce.value.Ok());
+                }
+            }
+            return Result.Ok(results);
+        });
+    }
+}
+//# sourceMappingURL=evento.js.map

package/ts/esm/evento.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"evento.js","sourceRoot":"","sources":["../../../src/evento.ts"],"names":[],"mappings":"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"}

package/ts/esm/evento.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evento.test.d.ts.map

package/ts/esm/evento.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evento.test.d.ts","sourceRoot":"","sources":["../../../src/evento.test.ts"],"names":[],"mappings":""}

package/ts/esm/evento.test.js

@@ -0,0 +1,520 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { Evento, EventoResult, EventoOp, EventoType, } from "./evento.js";
+import { Result } from "./result.js";
+import { Option } from "./option.js";
+class ReqResEventoEnDecoder {
+    async encode(args) {
+        const body = (await args.json());
+        return Result.Ok(body);
+    }
+    decode(data) {
+        return Promise.resolve(Result.Ok(JSON.stringify(data)));
+    }
+}
+class TestSend {
+    fn = vi.fn();
+    async start(trigger) {
+        this.fn("start", trigger);
+        return Promise.resolve(Result.Ok(undefined));
+    }
+    async send(trigger, data) {
+        const resData = data;
+        resData.encoderInfo = "test-encoder";
+        this.fn("send", trigger, resData);
+        return Promise.resolve(Result.Ok(resData));
+    }
+    async done(trigger) {
+        this.fn("done", trigger);
+        return Promise.resolve(Result.Ok(undefined));
+    }
+}
+describe("Evento", () => {
+    it("register ops push", () => {
+        const evo = new Evento(new ReqResEventoEnDecoder());
+        let r1 = [], r2 = [];
+        for (let i = 0; i < 5; i++) {
+            r1 = evo.push({
+                hash: "h1",
+                handle: async () => {
+                    return Promise.resolve(Result.Ok(EventoResult.Continue));
+                },
+            });
+            r2 = evo.push({
+                hash: "h2",
+                handle: async () => {
+                    return Promise.resolve(Result.Ok(EventoResult.Continue));
+                },
+            });
+        }
+        expect(evo.handlers().actions.map((h) => h.hash)).toEqual(["h1", "h2"]);
+        expect(evo.handlers().wildcards.length).toBe(0);
+        r1[0]();
+        expect(evo.handlers().actions.map((h) => h.hash)).toEqual(["h2"]);
+        expect(evo.handlers().wildcards.length).toBe(0);
+        r1[0]();
+        r2[0]();
+        expect(evo.handlers().actions.length).toBe(0);
+        expect(evo.handlers().wildcards.length).toBe(0);
+    });
+    it("register ops unshift", () => {
+        const evo = new Evento(new ReqResEventoEnDecoder());
+        for (let i = 0; i < 5; i++) {
+            evo.unshift({
+                hash: "h2",
+                handle: async () => {
+                    return Promise.resolve(Result.Ok(EventoResult.Continue));
+                },
+            });
+            evo.unshift({
+                hash: "h1",
+                handle: async () => {
+                    return Promise.resolve(Result.Ok(EventoResult.Continue));
+                },
+            });
+        }
+        expect(evo.handlers().actions.map((h) => h.hash)).toEqual(["h1", "h2"]);
+        expect(evo.handlers().wildcards.length).toBe(0);
+    });
+    it("register ops position", () => {
+        const evo = new Evento(new ReqResEventoEnDecoder());
+        for (let i = 0; i < 5; i++) {
+            evo.register({
+                op: EventoOp.Position,
+                type: EventoType.Regular,
+                idx: 1,
+                handler: {
+                    hash: "h2",
+                    handle: async () => {
+                        return Promise.resolve(Result.Ok(EventoResult.Continue));
+                    },
+                },
+            });
+            evo.register({
+                op: EventoOp.Position,
+                type: EventoType.Regular,
+                idx: 0,
+                handler: {
+                    hash: "h1",
+                    handle: async () => {
+                        return Promise.resolve(Result.Ok(EventoResult.Continue));
+                    },
+                },
+            });
+        }
+        expect(evo.handlers().actions.map((h) => h.hash)).toEqual(["h1", "h2"]);
+        expect(evo.handlers().wildcards.length).toBe(0);
+    });
+    it("wildcard ops push", () => {
+        const evo = new Evento(new ReqResEventoEnDecoder());
+        let r1 = [], r2 = [];
+        for (let i = 0; i < 5; i++) {
+            r1 = evo.push({
+                hash: "h1",
+                type: EventoType.WildCard,
+                handle: async () => {
+                    return Promise.resolve(Result.Ok(EventoResult.Continue));
+                },
+            });
+            r2 = evo.push({
+                hash: "h2",
+                type: EventoType.WildCard,
+                handle: async () => {
+                    return Promise.resolve(Result.Ok(EventoResult.Continue));
+                },
+            });
+        }
+        expect(evo.handlers().wildcards.map((h) => h.hash)).toEqual(["h1", "h2"]);
+        expect(evo.handlers().actions.length).toBe(0);
+        r1[0]();
+        expect(evo.handlers().wildcards.map((h) => h.hash)).toEqual(["h2"]);
+        expect(evo.handlers().actions.length).toBe(0);
+        r1[0]();
+        r2[0]();
+        expect(evo.handlers().actions.length).toBe(0);
+        expect(evo.handlers().wildcards.length).toBe(0);
+    });
+    const reqRes = new ReqResEventoEnDecoder();
+    const evo = new Evento(reqRes);
+    const send = new TestSend();
+    evo.push({
+        type: EventoType.WildCard,
+        hash: "wildcard-handler-first",
+        validate: (ctx) => {
+            const ret = (() => {
+                const test = ctx.enRequest;
+                if (test.x === 1) {
+                    return Result.Ok(Option.Some({ ...test, validated: true, step: "wildcard-first" }));
+                }
+                return Result.Ok(Option.None());
+            })();
+            send.fn("wildcard-first-validate", ctx, ret);
+            return Promise.resolve(ret);
+        },
+        handle: async (ctx) => {
+            const ret = ctx.send
+                .send(ctx, {
+                response: "ok",
+                req: ctx.validated,
+            })
+                .then((rv) => {
+                const v = rv.Ok();
+                let ret = Result.Ok(EventoResult.Continue);
+                if (v.req.stop) {
+                    ret = Result.Ok(EventoResult.Stop);
+                }
+                send.fn("wildcard-first-handle", ctx, v, ret);
+                return ret;
+            });
+            return ret;
+        },
+    }, {
+        type: EventoType.WildCard,
+        hash: "wildcard-second-handler",
+        validate: (ctx) => {
+            const ret = (() => {
+                const test = ctx.enRequest;
+                if (test.x === 1) {
+                    return Result.Ok(Option.Some({ ...test, validated: true, step: "wildcard-second" }));
+                }
+                return Result.Ok(Option.None());
+            })();
+            send.fn("wildcard-second-validate", ctx, ret);
+            return Promise.resolve(ret);
+        },
+        handle: async (ctx) => {
+            const ret = ctx.send
+                .send(ctx, {
+                response: "ok",
+                req: ctx.validated,
+            })
+                .then((rv) => {
+                const v = rv.Ok();
+                const ret = Result.Ok(EventoResult.Continue);
+                send.fn("wildcard-second-handle", ctx, v, ret);
+                return ret;
+            });
+            return ret;
+        },
+    }, {
+        hash: "regular-first-handler",
+        validate: (ctx) => {
+            const ret = (() => {
+                const test = ctx.enRequest;
+                if (test.x === 2) {
+                    return Result.Ok(Option.Some({ ...test, validated: true, step: "regular-first" }));
+                }
+                return Result.Ok(Option.None());
+            })();
+            send.fn("regular-first-validate", ctx, ret);
+            return Promise.resolve(ret);
+        },
+        handle: async (ctx) => {
+            const ret = ctx.send
+                .send(ctx, {
+                response: "ok",
+                req: ctx.validated,
+            })
+                .then((rv) => {
+                const v = rv.Ok();
+                let ret = Result.Ok(EventoResult.Continue);
+                if (v.req.stop) {
+                    ret = Result.Ok(EventoResult.Stop);
+                }
+                send.fn("regular-first-handle", ctx, v, ret);
+                return ret;
+            });
+            return ret;
+        },
+    }, {
+        hash: "regular-second-handler",
+        validate: (ctx) => {
+            const ret = (() => {
+                const test = ctx.enRequest;
+                if (test.x === 2) {
+                    return Result.Ok(Option.Some({ ...test, validated: true, step: "regular-second" }));
+                }
+                return Result.Ok(Option.None());
+            })();
+            send.fn("regular-second-validate", ctx, ret);
+            return Promise.resolve(ret);
+        },
+        handle: async (ctx) => {
+            const ret = ctx.send
+                .send(ctx, {
+                response: "ok",
+                req: ctx.validated,
+            })
+                .then((rv) => {
+                const v = rv.Ok();
+                const ret = Result.Ok(EventoResult.Continue);
+                send.fn("regular-second-handle", ctx, v, ret);
+                return ret;
+            });
+            return ret;
+        },
+    });
+    beforeEach(() => {
+        send.fn.mockClear();
+    });
+    it("continue:wildcard trigger", async () => {
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 1 }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-first-validate",
+            "regular-second-validate",
+            "wildcard-first-validate",
+            "start",
+            "send",
+            "wildcard-first-handle",
+            "wildcard-second-validate",
+            "send",
+            "wildcard-second-handle",
+            "done",
+        ]);
+        expect(send.fn.mock.calls[2]).toEqual([
+            "wildcard-first-validate",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 1 },
+                encoder: reqRes,
+                request,
+                send,
+            }),
+            Result.Ok(Option.Some({ validated: true, x: 1, step: "wildcard-first" })),
+        ]);
+        expect(send.fn.mock.calls[5]).toEqual([
+            "wildcard-first-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 1 },
+                encoder: reqRes,
+                request,
+                send,
+                validated: { validated: true, x: 1, step: "wildcard-first" },
+            }),
+            {
+                encoderInfo: "test-encoder",
+                req: {
+                    step: "wildcard-first",
+                    validated: true,
+                    x: 1,
+                },
+                response: "ok",
+            },
+            Result.Ok(EventoResult.Continue),
+        ]);
+        expect(send.fn.mock.calls[6]).toEqual([
+            "wildcard-second-validate",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 1 },
+                encoder: reqRes,
+                request,
+                send,
+            }),
+            Result.Ok(Option.Some({ validated: true, x: 1, step: "wildcard-second" })),
+        ]);
+        expect(send.fn.mock.calls[8]).toEqual([
+            "wildcard-second-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 1 },
+                encoder: reqRes,
+                request,
+                send,
+                validated: { validated: true, x: 1, step: "wildcard-second" },
+            }),
+            {
+                encoderInfo: "test-encoder",
+                req: {
+                    step: "wildcard-second",
+                    validated: true,
+                    x: 1,
+                },
+                response: "ok",
+            },
+            Result.Ok(EventoResult.Continue),
+        ]);
+    });
+    it("stop:wildcard trigger", async () => {
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 1, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-first-validate",
+            "regular-second-validate",
+            "wildcard-first-validate",
+            "start",
+            "send",
+            "wildcard-first-handle",
+            "done",
+        ]);
+        expect(send.fn.mock.calls[2]).toEqual([
+            "wildcard-first-validate",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 1, stop: true },
+                encoder: reqRes,
+                request,
+                send,
+            }),
+            Result.Ok(Option.Some({ validated: true, x: 1, stop: true, step: "wildcard-first" })),
+        ]);
+        expect(send.fn.mock.calls[5]).toEqual([
+            "wildcard-first-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 1, stop: true },
+                encoder: reqRes,
+                request,
+                send,
+                validated: { validated: true, x: 1, stop: true, step: "wildcard-first" },
+            }),
+            {
+                encoderInfo: "test-encoder",
+                req: {
+                    step: "wildcard-first",
+                    validated: true,
+                    stop: true,
+                    x: 1,
+                },
+                response: "ok",
+            },
+            Result.Ok(EventoResult.Stop),
+        ]);
+    });
+    it("continue:regular trigger", async () => {
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2 }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-first-validate",
+            "start",
+            "send",
+            "regular-first-handle",
+            "regular-second-validate",
+            "send",
+            "regular-second-handle",
+            "done",
+        ]);
+        expect(send.fn.mock.calls[0]).toEqual([
+            "regular-first-validate",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 2 },
+                encoder: reqRes,
+                request,
+                send,
+            }),
+            Result.Ok(Option.Some({ validated: true, x: 2, step: "regular-first" })),
+        ]);
+        expect(send.fn.mock.calls[3]).toEqual([
+            "regular-first-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 2 },
+                encoder: reqRes,
+                request,
+                send,
+                validated: { validated: true, x: 2, step: "regular-first" },
+            }),
+            {
+                encoderInfo: "test-encoder",
+                req: {
+                    step: "regular-first",
+                    validated: true,
+                    x: 2,
+                },
+                response: "ok",
+            },
+            Result.Ok(EventoResult.Continue),
+        ]);
+        expect(send.fn.mock.calls[4]).toEqual([
+            "regular-second-validate",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 2 },
+                encoder: reqRes,
+                request,
+                send,
+            }),
+            Result.Ok(Option.Some({ validated: true, x: 2, step: "regular-second" })),
+        ]);
+        expect(send.fn.mock.calls[6]).toEqual([
+            "regular-second-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 2 },
+                encoder: reqRes,
+                request,
+                send,
+                validated: { validated: true, x: 2, step: "regular-second" },
+            }),
+            {
+                encoderInfo: "test-encoder",
+                req: {
+                    step: "regular-second",
+                    validated: true,
+                    x: 2,
+                },
+                response: "ok",
+            },
+            Result.Ok(EventoResult.Continue),
+        ]);
+    });
+    it("stop:regular trigger", async () => {
+        const request = new Request("http://example.com", { method: "POST", body: JSON.stringify({ x: 2, stop: true }) });
+        await evo.trigger({
+            send,
+            request,
+        });
+        expect(send.fn.mock.calls.map((i) => i[0])).toEqual([
+            "regular-first-validate",
+            "start",
+            "send",
+            "regular-first-handle",
+            "done",
+        ]);
+        expect(send.fn.mock.calls[0]).toEqual([
+            "regular-first-validate",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 2, stop: true },
+                encoder: reqRes,
+                request,
+                send,
+            }),
+            Result.Ok(Option.Some({ validated: true, x: 2, stop: true, step: "regular-first" })),
+        ]);
+        expect(send.fn.mock.calls[3]).toEqual([
+            "regular-first-handle",
+            expect.objectContaining({
+                ctx: expect.anything(),
+                enRequest: { x: 2, stop: true },
+                encoder: reqRes,
+                request,
+                send,
+                validated: { validated: true, x: 2, stop: true, step: "regular-first" },
+            }),
+            {
+                encoderInfo: "test-encoder",
+                req: {
+                    step: "regular-first",
+                    validated: true,
+                    stop: true,
+                    x: 2,
+                },
+                response: "ok",
+            },
+            Result.Ok(EventoResult.Stop),
+        ]);
+    });
+});
+//# sourceMappingURL=evento.test.js.map