@m5kdev/backend 0.5.0 → 0.6.0

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

@@ -3,22 +3,33 @@ import type { Context, Session, User } from "../auth/auth.lib";
 import { Base } from "./base.abstract";
 import type { ServerResult, ServerResultAsync } from "./base.dto";
 import { type Entity, type ResourceActionGrant, type ResourceGrant } from "./base.grants";
-import type { BaseExternaRepository, BaseRepository } from "./base.repository";
-export declare class BaseService<Repositories extends Record<string, BaseRepository<any, any, any> | BaseExternaRepository>, Services extends Record<string, BaseService<any, any>>> extends Base {
+import { type PermissionServiceProcedureBuilder, type ServiceProcedureBuilder, type ServiceProcedureContext } from "./base.procedure";
+export type { PermissionServiceProcedureBuilder, ServiceProcedure, ServiceProcedureAccessConfig, ServiceProcedureAccessEntitiesConfig, ServiceProcedureAccessStateConfig, ServiceProcedureArgs, ServiceProcedureBuilder, ServiceProcedureContext, ServiceProcedureContextFilteredInput, ServiceProcedureContextFilterScope, ServiceProcedureEntityStepName, ServiceProcedureInputMapper, } from "./base.procedure";
+export declare class BaseService<Repositories extends Record<string, Base>, Services extends Record<string, Base>, DefaultContext extends ServiceProcedureContext = ServiceProcedureContext> extends Base {
     repository: Repositories;
     service: Services;
     constructor(repository?: Repositories, service?: Services);
-    addUserFilter(value: string, query?: QueryInput, columnId?: string, method?: QueryFilter["method"]): QueryInput;
+    addUserFilter(value: string, query?: undefined, columnId?: string, method?: QueryFilter["method"]): QueryInput;
+    addUserFilter<TQuery extends QueryInput>(value: string, query: TQuery, columnId?: string, method?: QueryFilter["method"]): TQuery;
+    protected procedure<TInput, TCtx extends ServiceProcedureContext = DefaultContext>(name: string): ServiceProcedureBuilder<TInput, TCtx, Repositories, Services>;
     addContextFilter(ctx: Context, include?: {
         user?: boolean;
         organization?: boolean;
         team?: boolean;
-    }, query?: QueryInput, map?: Record<string, {
+    }, query?: undefined, map?: Record<string, {
         columnId: string;
         method: QueryFilter["method"];
     }>): QueryInput;
+    addContextFilter<TQuery extends QueryInput>(ctx: Context, include: {
+        user?: boolean;
+        organization?: boolean;
+        team?: boolean;
+    } | undefined, query: TQuery, map?: Record<string, {
+        columnId: string;
+        method: QueryFilter["method"];
+    }>): TQuery;
 }
-export declare class BasePermissionService<Repositories extends Record<string, BaseRepository<any, any, any> | BaseExternaRepository>, Services extends Record<string, BaseService<any, any>>> extends BaseService<Repositories, Services> {
+export declare class BasePermissionService<Repositories extends Record<string, Base>, Services extends Record<string, Base>, DefaultContext extends ServiceProcedureContext = ServiceProcedureContext> extends BaseService<Repositories, Services, DefaultContext> {
     grants: ResourceGrant[];
     constructor(repository: Repositories, service: Services, grants?: ResourceGrant[]);
     accessGuard<T extends Entity>(ctx: {
@@ -29,6 +40,7 @@ export declare class BasePermissionService<Repositories extends Record<string, B
         session: Session;
         user: User;
     }, action: string, getEntities: () => ServerResultAsync<T | T[] | undefined>, grants?: ResourceActionGrant[]): ServerResultAsync<true>;
+    protected procedure<TInput, TCtx extends ServiceProcedureContext = DefaultContext>(name: string): PermissionServiceProcedureBuilder<TInput, TCtx, Repositories, Services>;
     checkPermission<T extends Entity>(ctx: {
         session: Session;
         user: User;

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

@@ -4,6 +4,7 @@ exports.BasePermissionService = exports.BaseService = void 0;
 const neverthrow_1 = require("neverthrow");
 const base_abstract_1 = require("./base.abstract");
 const base_grants_1 = require("./base.grants");
+const base_procedure_1 = require("./base.procedure");
 class BaseService extends base_abstract_1.Base {
     repository;
     service;
@@ -25,6 +26,9 @@ class BaseService extends base_abstract_1.Base {
             ? { ...query, filters: [...(query?.filters ?? []), userFilter] }
             : { filters: [userFilter] };
     }
+    procedure(name) {
+        return (0, base_procedure_1.createServiceProcedureBuilder)(this, { name, steps: [] });
+    }
     addContextFilter(ctx, include = {
         user: true,
         organization: false,
@@ -92,6 +96,9 @@ class BasePermissionService extends BaseService {
             return this.error("FORBIDDEN");
         return (0, neverthrow_1.ok)(true);
     }
+    procedure(name) {
+        return (0, base_procedure_1.createPermissionServiceProcedureBuilder)(this, { name, steps: [] });
+    }
     checkPermission(ctx, action, entities, grants) {
         const actionGrants = grants ?? this.grants.filter((grant) => grant.action === action);
         return (0, base_grants_1.checkPermissionSync)(ctx, actionGrants, entities);

package/dist/src/modules/base/base.service.test.d.ts

@@ -0,0 +1 @@
+export {};

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,43 +16,43 @@ 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<{
-        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;
     }>>;
     refreshToken(connectionId: string): 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.trpc.d.ts

@@ -12,20 +12,20 @@ export declare function createConnectTRPC({ router, privateProcedure: procedure
             inactive?: boolean | undefined;
         };
         output: {
-            provider: string;
             id: string;
             createdAt: Date;
             userId: string;
+            provider: string;
             accountType: string;
             providerAccountId: string;
             updatedAt?: Date | 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;
-            parentId?: string | null | undefined;
             metadataJson?: unknown;
             revokedAt?: Date | null | undefined;
             lastRefreshedAt?: Date | 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())