@m5kdev/backend 0.7.0 → 0.8.0

package/dist/src/modules/base/base.service.test.js

@@ -1,443 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const neverthrow_1 = require("neverthrow");
-const errors_1 = require("../../utils/errors");
-const base_actor_1 = require("./base.actor");
-const base_service_1 = require("./base.service");
-function createActor(overrides = {}) {
-    const actor = (0, base_actor_1.createServiceActor)({
-        userId: "user-1",
-        userRole: "member",
-        organizationId: null,
-        organizationRole: null,
-        teamId: null,
-        teamRole: null,
-        ...overrides,
-    });
-    if (!actor) {
-        throw new Error("Expected actor");
-    }
-    return actor;
-}
-function createOrganizationActor(overrides = {}) {
-    return createActor({
-        organizationId: "org-1",
-        organizationRole: "owner",
-        ...overrides,
-    });
-}
-function createTeamActor(overrides = {}) {
-    return createActor({
-        organizationId: "org-1",
-        organizationRole: "owner",
-        teamId: "team-1",
-        teamRole: "member",
-        ...overrides,
-    });
-}
-describe("BaseService procedure builder", () => {
-    it("runs chained steps in order and exposes state by step name", async () => {
-        const events = [];
-        class PipelineService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .use("trimmed", ({ input }) => {
-                events.push("trimmed");
-                return input.value.trim();
-            })
-                .use("upper", ({ state }) => {
-                events.push("upper");
-                return state.trimmed.toUpperCase();
-            })
-                .handle(({ state }) => {
-                events.push("handler");
-                return (0, neverthrow_1.ok)({
-                    trimmed: state.trimmed,
-                    upper: state.upper,
-                });
-            });
-        }
-        const service = new PipelineService();
-        const result = await service.run({ value: "  hello  " }, {});
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value).toEqual({
-                trimmed: "hello",
-                upper: "HELLO",
-            });
-        }
-        expect(events).toEqual(["trimmed", "upper", "handler"]);
-    });
-    it("addContextFilter wraps auth and maps query input with the default step name", async () => {
-        class QueryService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .addContextFilter(["user", "organization"])
-                .handle(({ input, state }) => (0, neverthrow_1.ok)({
-                input,
-                stateMatches: state.contextFilter === input,
-            }));
-        }
-        const service = new QueryService();
-        const unauthorized = await service.run({ search: "hello" }, {});
-        expect(unauthorized.isErr()).toBe(true);
-        if (unauthorized.isErr()) {
-            expect(unauthorized.error.code).toBe("UNAUTHORIZED");
-        }
-        const authorized = await service.run({ search: "hello" }, {
-            actor: createOrganizationActor(),
-        });
-        expect(authorized.isOk()).toBe(true);
-        if (authorized.isOk()) {
-            expect(authorized.value.input.search).toBe("hello");
-            expect(authorized.value.stateMatches).toBe(true);
-            expect(authorized.value.input.filters).toEqual([
-                {
-                    columnId: "userId",
-                    type: "string",
-                    method: "equals",
-                    value: "user-1",
-                },
-                {
-                    columnId: "organizationId",
-                    type: "string",
-                    method: "equals",
-                    value: "org-1",
-                },
-            ]);
-        }
-    });
-    it("addContextFilter returns FORBIDDEN when the actor scope is too small", async () => {
-        class QueryService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .addContextFilter(["organization"])
-                .handle(({ input }) => (0, neverthrow_1.ok)(input));
-        }
-        const service = new QueryService();
-        const result = await service.run({ search: "hello" }, {
-            actor: createActor(),
-        });
-        expect(result.isErr()).toBe(true);
-        if (result.isErr()) {
-            expect(result.error.code).toBe("FORBIDDEN");
-        }
-    });
-    it("mapInput updates the input seen by later steps and the handler", async () => {
-        class QueryService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .requireAuth()
-                .mapInput("scopedQuery", ({ input, ctx }) => this.addContextFilter(ctx.actor, { user: true, organization: true, team: true }, input, {
-                userId: {
-                    columnId: "authorUserId",
-                    method: "equals",
-                },
-                organizationId: {
-                    columnId: "organizationId",
-                    method: "equals",
-                },
-                teamId: {
-                    columnId: "teamId",
-                    method: "equals",
-                },
-            }))
-                .use("filterCount", ({ input }) => input.filters?.length ?? 0)
-                .handle(({ input, state }) => (0, neverthrow_1.ok)({
-                input,
-                filterCount: state.filterCount,
-                scopedInputMatches: state.scopedQuery === input,
-            }));
-        }
-        const service = new QueryService();
-        const result = await service.run({ search: "hello" }, {
-            actor: createTeamActor(),
-        });
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value.input.search).toBe("hello");
-            expect(result.value.filterCount).toBe(3);
-            expect(result.value.scopedInputMatches).toBe(true);
-            expect(result.value.input.filters).toEqual([
-                {
-                    columnId: "authorUserId",
-                    type: "string",
-                    method: "equals",
-                    value: "user-1",
-                },
-                {
-                    columnId: "organizationId",
-                    type: "string",
-                    method: "equals",
-                    value: "org-1",
-                },
-                {
-                    columnId: "teamId",
-                    type: "string",
-                    method: "equals",
-                    value: "team-1",
-                },
-            ]);
-        }
-    });
-    it("uses the base service default context type for procedures", async () => {
-        class ContextService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .requireAuth()
-                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.requestId}:${ctx.actor.userId}:${input.value}`));
-        }
-        const service = new ContextService();
-        const result = await service.run({ value: "ok" }, {
-            requestId: "req-1",
-            actor: createActor(),
-        });
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value).toBe("req-1:user-1:ok");
-        }
-    });
-    it("requireAuth rejects missing auth context", async () => {
-        class ProtectedService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .requireAuth()
-                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.actor.userId}:${input.value}`));
-        }
-        const service = new ProtectedService();
-        const result = await service.run({ value: "x" }, {});
-        expect(result.isErr()).toBe(true);
-        if (result.isErr()) {
-            expect(result.error.code).toBe("UNAUTHORIZED");
-        }
-    });
-    it("requireAuth allows valid context", async () => {
-        class ProtectedService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .requireAuth()
-                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.actor.userId}:${input.value}`));
-        }
-        const service = new ProtectedService();
-        const result = await service.run({ value: "ok" }, { actor: createActor() });
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value).toBe("user-1:ok");
-        }
-    });
-    it("requireAuth accepts organization actors for organization scope", async () => {
-        class ProtectedService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .requireAuth("organization")
-                .handle(({ ctx }) => (0, neverthrow_1.ok)(ctx.actor.organizationId));
-        }
-        const service = new ProtectedService();
-        const result = await service.run(undefined, {
-            actor: createOrganizationActor(),
-        });
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value).toBe("org-1");
-        }
-    });
-    it("requireAuth rejects actors without the requested team scope", async () => {
-        class ProtectedService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .requireAuth("team")
-                .handle(({ ctx }) => (0, neverthrow_1.ok)(ctx.actor.teamId));
-        }
-        const service = new ProtectedService();
-        const result = await service.run(undefined, {
-            actor: createOrganizationActor(),
-        });
-        expect(result.isErr()).toBe(true);
-        if (result.isErr()) {
-            expect(result.error.code).toBe("FORBIDDEN");
-        }
-    });
-    it("normalizes thrown async errors through throwableAsync", async () => {
-        class ThrowingService extends base_service_1.BaseService {
-            run = this.procedure("run").handle(async () => {
-                throw new Error("boom");
-            });
-        }
-        const service = new ThrowingService();
-        const result = await service.run(undefined, {});
-        expect(result.isErr()).toBe(true);
-        if (result.isErr()) {
-            expect(result.error.code).toBe("INTERNAL_SERVER_ERROR");
-            expect(result.error.cause).toBeInstanceOf(Error);
-        }
-    });
-    it("logs metadata stages without input or context payloads", async () => {
-        class LoggedService extends base_service_1.BaseService {
-            run = this.procedure("run")
-                .requireAuth()
-                .handle(({ ctx }) => (0, neverthrow_1.ok)(ctx.actor.userId));
-        }
-        const service = new LoggedService();
-        const debugSpy = jest.fn();
-        service.logger.debug = debugSpy;
-        const result = await service.run({ secret: "top-secret" }, {
-            actor: createActor(),
-            token: "super-token",
-        });
-        expect(result.isOk()).toBe(true);
-        expect(debugSpy).toHaveBeenCalledTimes(3);
-        const payloads = debugSpy.mock.calls.map(([payload]) => payload);
-        expect(payloads.map((payload) => payload.stage)).toEqual(["start", "auth_passed", "success"]);
-        const serializedPayloads = JSON.stringify(payloads);
-        expect(serializedPayloads).not.toContain("top-secret");
-        expect(serializedPayloads).not.toContain("super-token");
-        expect(payloads.every((payload) => "hasActor" in payload)).toBe(true);
-        expect(payloads.every((payload) => !("input" in payload))).toBe(true);
-        expect(payloads.every((payload) => !("ctx" in payload))).toBe(true);
-    });
-});
-describe("BasePermissionService procedure builder", () => {
-    it("passes loaded entities into the handler when access is granted", async () => {
-        const grants = [
-            {
-                action: "read",
-                level: "user",
-                role: "member",
-                access: "own",
-            },
-        ];
-        class PermissionService extends base_service_1.BasePermissionService {
-            constructor() {
-                super({}, {}, grants);
-            }
-            run = this.procedure("run")
-                .access({
-                action: "read",
-                entities: ({ input }) => ({
-                    userId: input.ownerId,
-                }),
-            })
-                .handle(({ state }) => (0, neverthrow_1.ok)(state.access?.userId ?? null));
-        }
-        const service = new PermissionService();
-        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value).toBe("user-1");
-        }
-    });
-    it("reuses a typed state step directly when entityStep is provided", async () => {
-        const grants = [
-            {
-                action: "read",
-                level: "user",
-                role: "member",
-                access: "own",
-            },
-        ];
-        class PermissionService extends base_service_1.BasePermissionService {
-            constructor() {
-                super({}, {}, grants);
-            }
-            run = this.procedure("run")
-                .use("record", ({ input }) => (0, neverthrow_1.ok)({
-                id: "resource-1",
-                userId: input.ownerId,
-                teamId: null,
-                organizationId: null,
-            }))
-                .access({
-                action: "read",
-                entityStep: "record",
-            })
-                .handle(({ state }) => (0, neverthrow_1.ok)(state.access === state.record));
-        }
-        const service = new PermissionService();
-        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value).toBe(true);
-        }
-    });
-    it("returns FORBIDDEN when access validation fails", async () => {
-        const grants = [
-            {
-                action: "read",
-                level: "user",
-                role: "member",
-                access: "own",
-            },
-        ];
-        class PermissionService extends base_service_1.BasePermissionService {
-            constructor() {
-                super({}, {}, grants);
-            }
-            run = this.procedure("run")
-                .access({
-                action: "read",
-                entities: ({ input }) => ({
-                    userId: input.ownerId,
-                }),
-            })
-                .handle(() => (0, neverthrow_1.ok)("allowed"));
-        }
-        const service = new PermissionService();
-        const result = await service.run({ ownerId: "other-user" }, { actor: createActor() });
-        expect(result.isErr()).toBe(true);
-        if (result.isErr()) {
-            expect(result.error.code).toBe("FORBIDDEN");
-        }
-    });
-    it("propagates entity loader failures through access", async () => {
-        const grants = [
-            {
-                action: "read",
-                level: "user",
-                role: "member",
-                access: "own",
-            },
-        ];
-        class PermissionService extends base_service_1.BasePermissionService {
-            constructor() {
-                super({}, {}, grants);
-            }
-            run = this.procedure("run")
-                .access({
-                action: "read",
-                entities: async () => (0, neverthrow_1.err)(new errors_1.ServerError({
-                    code: "NOT_FOUND",
-                    layer: "service",
-                    layerName: "PermissionService",
-                    message: "Missing entity",
-                })),
-            })
-                .handle(() => (0, neverthrow_1.ok)("allowed"));
-        }
-        const service = new PermissionService();
-        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
-        expect(result.isErr()).toBe(true);
-        if (result.isErr()) {
-            expect(result.error.code).toBe("INTERNAL_SERVER_ERROR");
-        }
-    });
-    it("skips entity loading when grants already allow all access", async () => {
-        const grants = [
-            {
-                action: "read",
-                level: "user",
-                role: "member",
-                access: "all",
-            },
-        ];
-        const resolveEntity = jest.fn(async () => ({ userId: "user-1" }));
-        class PermissionService extends base_service_1.BasePermissionService {
-            constructor() {
-                super({}, {}, grants);
-            }
-            run = this.procedure("run")
-                .access({
-                action: "read",
-                entities: resolveEntity,
-            })
-                .handle(() => (0, neverthrow_1.ok)("allowed"));
-        }
-        const service = new PermissionService();
-        const result = await service.run({ ownerId: "other-user" }, { actor: createActor() });
-        expect(result.isOk()).toBe(true);
-        if (result.isOk()) {
-            expect(result.value).toBe("allowed");
-        }
-        expect(resolveEntity).not.toHaveBeenCalled();
-    });
-});

package/dist/src/modules/base/base.types.d.ts

@@ -1 +0,0 @@
-export type ServerErrorLayer = "unknown" | "repository" | "service" | "controller" | "auth" | "workflow";

package/dist/src/modules/base/base.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });