@m5kdev/backend 0.4.0 → 0.6.0

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

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../../utils/errors");
+const base_service_1 = require("./base.service");
+function createUser(overrides = {}) {
+    return {
+        id: "user-1",
+        role: "member",
+        email: "user@example.com",
+        name: "User",
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        banned: false,
+        banReason: null,
+        banExpires: null,
+        emailVerified: true,
+        image: null,
+        onboarding: null,
+        preferences: null,
+        flags: null,
+        stripeCustomerId: null,
+        paymentCustomerId: null,
+        paymentPlanTier: null,
+        paymentPlanExpiresAt: null,
+        ...overrides,
+    };
+}
+function createSession(overrides = {}) {
+    return {
+        id: "session-1",
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        expiresAt: new Date(Date.now() + 1000 * 60 * 60),
+        token: "token",
+        ipAddress: null,
+        userAgent: null,
+        userId: "user-1",
+        activeOrganizationId: null,
+        activeOrganizationRole: null,
+        activeTeamId: null,
+        activeTeamRole: null,
+        impersonatedBy: null,
+        ...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" }, {
+            user: createUser(),
+            session: createSession({
+                activeOrganizationId: "org-1",
+            }),
+        });
+        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("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, { 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" }, {
+            user: createUser(),
+            session: createSession({
+                activeOrganizationId: "org-1",
+                activeTeamId: "team-1",
+            }),
+        });
+        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.user.id}:${input.value}`));
+        }
+        const service = new ContextService();
+        const result = await service.run({ value: "ok" }, {
+            requestId: "req-1",
+            user: createUser(),
+            session: createSession(),
+        });
+        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.user.id}:${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.user.id}:${input.value}`));
+        }
+        const service = new ProtectedService();
+        const result = await service.run({ value: "ok" }, { user: createUser(), session: createSession() });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe("user-1:ok");
+        }
+    });
+    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.user.id));
+        }
+        const service = new LoggedService();
+        const debugSpy = jest.fn();
+        service.logger.debug = debugSpy;
+        const result = await service.run({ secret: "top-secret" }, {
+            user: createUser(),
+            session: createSession(),
+            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) => !("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" }, { user: createUser(), session: createSession() });
+        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" }, { user: createUser(), session: createSession() });
+        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" }, { user: createUser(), session: createSession() });
+        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" }, { user: createUser(), session: createSession() });
+        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" }, { user: createUser(), session: createSession() });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe("allowed");
+        }
+        expect(resolveEntity).not.toHaveBeenCalled();
+    });
+});

package/dist/src/modules/connect/connect.repository.d.ts

@@ -389,22 +389,22 @@ export declare class ConnectRepository extends BaseTableRepository<Orm, Schema,
         updatedAt: Date | null;
     }[]>>;
     upsert(data: ConnectInsert, tx?: Orm): Promise<import("../base/base.dto").ServerResult<{
-        provider: string;
         id: string;
         createdAt: Date;
         updatedAt: Date | null;
-        userId: string;
         expiresAt: Date | null;
+        userId: string;
+        parentId: string | null;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
+        provider: string;
         accountType: string;
         providerAccountId: string;
         handle: string | null;
         displayName: string | null;
         avatarUrl: string | null;
         tokenType: string | null;
-        parentId: string | null;
         metadataJson: unknown;
         revokedAt: Date | null;
         lastRefreshedAt: Date | null;

package/dist/src/modules/connect/connect.service.d.ts

@@ -16,19 +16,19 @@ export declare class ConnectService extends BaseService<{
         url: string;
     }>;
     handleCallback(user: User, sessionId: string, providerId: string, code: string, state: string): Promise<import("../base/base.dto").ServerResult<{
-        handle: string | null;
         id: string;
         createdAt: Date;
         updatedAt: Date | null;
+        expiresAt: Date | null;
         userId: string;
         parentId: string | null;
-        expiresAt: Date | null;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
         provider: string;
         accountType: string;
         providerAccountId: string;
+        handle: string | null;
         displayName: string | null;
         avatarUrl: string | null;
         tokenType: string | null;
@@ -37,19 +37,19 @@ export declare class ConnectService extends BaseService<{
         lastRefreshedAt: Date | null;
     }>>;
     refreshToken(connectionId: string): Promise<import("../base/base.dto").ServerResult<{
-        handle: string | null;
         id: string;
         createdAt: Date;
         updatedAt: Date | null;
+        expiresAt: Date | null;
         userId: string;
         parentId: string | null;
-        expiresAt: Date | null;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
         provider: string;
         accountType: string;
         providerAccountId: string;
+        handle: string | null;
         displayName: string | null;
         avatarUrl: string | null;
         tokenType: string | null;

package/dist/src/modules/connect/connect.trpc.d.ts

@@ -18,11 +18,11 @@ export declare function createConnectTRPC({ router, privateProcedure: procedure
             provider: string;
             accountType: string;
             providerAccountId: string;
-            handle?: string | null | undefined;
             updatedAt?: Date | null | undefined;
-            parentId?: string | null | undefined;
             expiresAt?: Date | null | undefined;
+            parentId?: string | null | undefined;
             scope?: string | null | undefined;
+            handle?: string | null | undefined;
             displayName?: string | null | undefined;
             avatarUrl?: string | null | undefined;
             tokenType?: string | null | undefined;

package/dist/src/modules/recurrence/recurrence.service.d.ts

@@ -1,20 +1,41 @@
 import type { CreateRecurrenceSchema, DeleteRecurrenceRulesSchema, DeleteRecurrenceSchema, UpdateRecurrenceRulesSchema, UpdateRecurrenceSchema } from "@m5kdev/commons/modules/recurrence/recurrence.schema";
-import type { QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
-import type { Context, User } from "../auth/auth.lib";
+import type { Context } from "../auth/auth.lib";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
 import type { CreateWithRulesResult, RecurrenceRepository, RecurrenceRulesRepository } from "./recurrence.repository";
 export declare class RecurrenceService extends BaseService<{
     recurrence: RecurrenceRepository;
     recurrenceRules: RecurrenceRulesRepository;
-}, Record<string, never>> {
-    create(data: CreateRecurrenceSchema, ctx: Context): ServerResultAsync<CreateWithRulesResult>;
-    list(query?: QueryInput, ctx?: {
-        user?: User;
-    }): ServerResultAsync<{
-        rows: CreateWithRulesResult["recurrence"][];
+}, Record<string, never>, Context> {
+    readonly list: import("../base/base.procedure").ServiceProcedure<{
+        page?: number | undefined;
+        limit?: number | undefined;
+        sort?: string | undefined;
+        order?: "asc" | "desc" | undefined;
+        filters?: {
+            columnId: string;
+            type: "string" | "number" | "boolean" | "date" | "enum";
+            method: "on" | "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "between" | "before" | "after" | "oneOf" | "intersect" | "isEmpty" | "isNotEmpty" | "is_null" | "is_not_null";
+            value: string | number | boolean | string[];
+            valueTo?: string | undefined;
+            endColumnId?: string | undefined;
+        }[] | undefined;
+    }, Context, {
+        rows: {
+            id: string;
+            name: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            metadata: Record<string, any> | null;
+            userId: string | null;
+            teamId: string | null;
+            organizationId: string | null;
+            enabled: boolean;
+            kind: string | null;
+        }[];
         total: number;
     }>;
+    create(data: CreateRecurrenceSchema, ctx: Context): ServerResultAsync<CreateWithRulesResult>;
     findById(id: string): ServerResultAsync<CreateWithRulesResult["recurrence"] | null>;
     update(data: UpdateRecurrenceSchema & {
         id: string;

package/dist/src/modules/recurrence/recurrence.service.js

@@ -31,6 +31,9 @@ function mapRuleToInsert(rule) {
     return out;
 }
 class RecurrenceService extends base_service_1.BaseService {
+    list = this.procedure("list")
+        .addContextFilter(["user"])
+        .handle(({ input }) => this.repository.recurrence.queryList(input));
     async create(data, ctx) {
         const recurrenceData = {
             name: data.name,
@@ -44,10 +47,6 @@ class RecurrenceService extends base_service_1.BaseService {
         const rulesData = data.recurrenceRules.map(mapRuleToInsert);
         return this.repository.recurrence.createWithRules(recurrenceData, rulesData);
     }
-    async list(query, ctx) {
-        const queryWithUser = ctx?.user ? this.addUserFilter(ctx.user.id, query, "userId") : query;
-        return this.repository.recurrence.queryList(queryWithUser);
-    }
     async findById(id) {
         const result = await this.repository.recurrence.findById(id);
         if (result.isErr())

package/dist/src/modules/recurrence/recurrence.trpc.d.ts

@@ -1,5 +1,5 @@
-import type { RecurrenceService } from "./recurrence.service";
 import { type TRPCMethods } from "../../utils/trpc";
+import type { RecurrenceService } from "./recurrence.service";
 export declare function createRecurrenceTRPC({ router, privateProcedure: procedure }: TRPCMethods, recurrenceService: RecurrenceService): import("@trpc/server").TRPCBuiltRouter<{
     ctx: import("../auth/auth.lib").Context;
     meta: any;
@@ -11,11 +11,11 @@ export declare function createRecurrenceTRPC({ router, privateProcedure: procedu
             page?: number | undefined;
             limit?: number | undefined;
             sort?: string | undefined;
-            order?: "desc" | "asc" | undefined;
+            order?: "asc" | "desc" | undefined;
             filters?: {
                 columnId: string;
                 type: "string" | "number" | "boolean" | "date" | "enum";
-                method: "intersect" | "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "on" | "between" | "before" | "after" | "oneOf" | "isEmpty" | "isNotEmpty" | "is_null" | "is_not_null";
+                method: "on" | "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "between" | "before" | "after" | "oneOf" | "intersect" | "isEmpty" | "isNotEmpty" | "is_null" | "is_not_null";
                 value: string | number | boolean | string[];
                 valueTo?: string | undefined;
                 endColumnId?: string | undefined;

package/dist/src/modules/recurrence/recurrence.trpc.js

@@ -20,7 +20,7 @@ const deleteRecurrenceOutputSchema = zod_1.z.object({ id: zod_1.z.string() });
 function createRecurrenceTRPC({ router, privateProcedure: procedure }, recurrenceService) {
     return router({
         list: procedure
-            .input(query_schema_1.querySchema.optional())
+            .input(query_schema_1.querySchema.default({}))
             .output(listRecurrenceOutputSchema)
             .query(async ({ ctx, input }) => {
             return (0, trpc_1.handleTRPCResult)(await recurrenceService.list(input, ctx));

package/dist/src/modules/tag/tag.db.js

@@ -36,7 +36,7 @@ exports.taggings = (0, sqlite_core_1.sqliteTable)("taggings", {
         .$default(() => new Date()),
     tagId: (0, sqlite_core_1.text)("tag_id")
         .notNull()
-        .references(() => exports.tags.id),
+        .references(() => exports.tags.id, { onDelete: "cascade" }),
     resourceType: (0, sqlite_core_1.text)("resource_type").notNull(), // e.g., "post", "image"
     resourceId: (0, sqlite_core_1.text)("resource_id").notNull(), // id in the resource table
 });