@m5kdev/backend 0.6.0 → 0.7.0

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BasePermissionService = exports.BaseService = void 0;
 const neverthrow_1 = require("neverthrow");
 const base_abstract_1 = require("./base.abstract");
+const base_actor_1 = require("./base.actor");
 const base_grants_1 = require("./base.grants");
 const base_procedure_1 = require("./base.procedure");
 class BaseService extends base_abstract_1.Base {
@@ -29,7 +30,7 @@ class BaseService extends base_abstract_1.Base {
     procedure(name) {
         return (0, base_procedure_1.createServiceProcedureBuilder)(this, { name, steps: [] });
     }
-    addContextFilter(ctx, include = {
+    addContextFilter(actor, include = {
         user: true,
         organization: false,
         team: false,
@@ -53,23 +54,29 @@ class BaseService extends base_abstract_1.Base {
                 columnId: map.userId.columnId,
                 type: "string",
                 method: map.userId.method,
-                value: ctx.user.id,
+                value: actor.userId,
             });
         }
         if (include.organization) {
+            if (!(0, base_actor_1.validateActor)(actor, "organization")) {
+                throw new Error("Organization-scoped context filter requires an organization actor");
+            }
             filters.push({
                 columnId: map.organizationId.columnId,
                 type: "string",
                 method: map.organizationId.method,
-                value: ctx.session.activeOrganizationId ?? "",
+                value: actor.organizationId,
             });
         }
         if (include.team) {
+            if (!(0, base_actor_1.validateActor)(actor, "team")) {
+                throw new Error("Team-scoped context filter requires a team actor");
+            }
             filters.push({
                 columnId: map.teamId.columnId,
                 type: "string",
                 method: map.teamId.method,
-                value: ctx.session.activeTeamId ?? "",
+                value: actor.teamId,
             });
         }
         return query ? { ...query, filters: [...(query?.filters ?? []), ...filters] } : { filters };
@@ -82,14 +89,14 @@ class BasePermissionService extends BaseService {
         super(repository, service);
         this.grants = grants;
     }
-    accessGuard(ctx, action, entities, grants) {
-        const hasPermission = this.checkPermission(ctx, action, entities, grants);
+    accessGuard(actor, action, entities, grants) {
+        const hasPermission = this.checkPermission(actor, action, entities, grants);
         if (!hasPermission)
             return this.error("FORBIDDEN");
         return (0, neverthrow_1.ok)(true);
     }
-    async accessGuardAsync(ctx, action, getEntities, grants) {
-        const hasPermission = await this.checkPermissionAsync(ctx, action, getEntities, grants);
+    async accessGuardAsync(actor, action, getEntities, grants) {
+        const hasPermission = await this.checkPermissionAsync(actor, action, getEntities, grants);
         if (hasPermission.isErr())
             return (0, neverthrow_1.err)(hasPermission.error);
         if (!hasPermission.value)
@@ -99,13 +106,13 @@ class BasePermissionService extends BaseService {
     procedure(name) {
         return (0, base_procedure_1.createPermissionServiceProcedureBuilder)(this, { name, steps: [] });
     }
-    checkPermission(ctx, action, entities, grants) {
+    checkPermission(actor, action, entities, grants) {
         const actionGrants = grants ?? this.grants.filter((grant) => grant.action === action);
-        return (0, base_grants_1.checkPermissionSync)(ctx, actionGrants, entities);
+        return (0, base_grants_1.checkPermissionSync)(actor, actionGrants, entities);
     }
-    async checkPermissionAsync(ctx, action, getEntities, grants) {
+    async checkPermissionAsync(actor, action, getEntities, grants) {
         const actionGrants = grants ?? this.grants.filter((grant) => grant.action === action);
-        const permission = await (0, base_grants_1.checkPermissionAsync)(ctx, actionGrants, getEntities);
+        const permission = await (0, base_grants_1.checkPermissionAsync)(actor, actionGrants, getEntities);
         if (permission.isErr())
             return this.error("INTERNAL_SERVER_ERROR", "Failed to check permission", {
                 cause: permission.error,

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

@@ -2,47 +2,38 @@
 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 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,
+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 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,
+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 () => {
@@ -92,10 +83,7 @@ describe("BaseService procedure builder", () => {
             expect(unauthorized.error.code).toBe("UNAUTHORIZED");
         }
         const authorized = await service.run({ search: "hello" }, {
-            user: createUser(),
-            session: createSession({
-                activeOrganizationId: "org-1",
-            }),
+            actor: createOrganizationActor(),
         });
         expect(authorized.isOk()).toBe(true);
         if (authorized.isOk()) {
@@ -117,11 +105,26 @@ describe("BaseService procedure builder", () => {
             ]);
         }
     });
+    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, { user: true, organization: true, team: true }, input, {
+                .mapInput("scopedQuery", ({ input, ctx }) => this.addContextFilter(ctx.actor, { user: true, organization: true, team: true }, input, {
                 userId: {
                     columnId: "authorUserId",
                     method: "equals",
@@ -144,11 +147,7 @@ describe("BaseService procedure builder", () => {
         }
         const service = new QueryService();
         const result = await service.run({ search: "hello" }, {
-            user: createUser(),
-            session: createSession({
-                activeOrganizationId: "org-1",
-                activeTeamId: "team-1",
-            }),
+            actor: createTeamActor(),
         });
         expect(result.isOk()).toBe(true);
         if (result.isOk()) {
@@ -181,13 +180,12 @@ describe("BaseService procedure builder", () => {
         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}`));
+                .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",
-            user: createUser(),
-            session: createSession(),
+            actor: createActor(),
         });
         expect(result.isOk()).toBe(true);
         if (result.isOk()) {
@@ -198,7 +196,7 @@ describe("BaseService procedure builder", () => {
         class ProtectedService extends base_service_1.BaseService {
             run = this.procedure("run")
                 .requireAuth()
-                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.user.id}:${input.value}`));
+                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.actor.userId}:${input.value}`));
         }
         const service = new ProtectedService();
         const result = await service.run({ value: "x" }, {});
@@ -211,15 +209,45 @@ describe("BaseService procedure builder", () => {
         class ProtectedService extends base_service_1.BaseService {
             run = this.procedure("run")
                 .requireAuth()
-                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.user.id}:${input.value}`));
+                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.actor.userId}:${input.value}`));
         }
         const service = new ProtectedService();
-        const result = await service.run({ value: "ok" }, { user: createUser(), session: createSession() });
+        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 () => {
@@ -238,14 +266,13 @@ describe("BaseService procedure builder", () => {
         class LoggedService extends base_service_1.BaseService {
             run = this.procedure("run")
                 .requireAuth()
-                .handle(({ ctx }) => (0, neverthrow_1.ok)(ctx.user.id));
+                .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" }, {
-            user: createUser(),
-            session: createSession(),
+            actor: createActor(),
             token: "super-token",
         });
         expect(result.isOk()).toBe(true);
@@ -255,6 +282,7 @@ describe("BaseService procedure builder", () => {
         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);
     });
@@ -283,7 +311,7 @@ describe("BasePermissionService procedure builder", () => {
                 .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() });
+        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
         expect(result.isOk()).toBe(true);
         if (result.isOk()) {
             expect(result.value).toBe("user-1");
@@ -316,7 +344,7 @@ describe("BasePermissionService procedure builder", () => {
                 .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() });
+        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
         expect(result.isOk()).toBe(true);
         if (result.isOk()) {
             expect(result.value).toBe(true);
@@ -345,7 +373,7 @@ describe("BasePermissionService procedure builder", () => {
                 .handle(() => (0, neverthrow_1.ok)("allowed"));
         }
         const service = new PermissionService();
-        const result = await service.run({ ownerId: "other-user" }, { user: createUser(), session: createSession() });
+        const result = await service.run({ ownerId: "other-user" }, { actor: createActor() });
         expect(result.isErr()).toBe(true);
         if (result.isErr()) {
             expect(result.error.code).toBe("FORBIDDEN");
@@ -377,7 +405,7 @@ describe("BasePermissionService procedure builder", () => {
                 .handle(() => (0, neverthrow_1.ok)("allowed"));
         }
         const service = new PermissionService();
-        const result = await service.run({ ownerId: "user-1" }, { user: createUser(), session: createSession() });
+        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");
@@ -405,7 +433,7 @@ describe("BasePermissionService procedure builder", () => {
                 .handle(() => (0, neverthrow_1.ok)("allowed"));
         }
         const service = new PermissionService();
-        const result = await service.run({ ownerId: "other-user" }, { user: createUser(), session: createSession() });
+        const result = await service.run({ ownerId: "other-user" }, { actor: createActor() });
         expect(result.isOk()).toBe(true);
         if (result.isOk()) {
             expect(result.value).toBe("allowed");

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

@@ -1,6 +1,8 @@
+import type { BillingSchema } from "@m5kdev/commons/modules/billing/billing.schema";
 import type Stripe from "stripe";
 import type { User } from "../auth/auth.lib";
 import type { ServerResult, ServerResultAsync } from "../base/base.dto";
+import type { Context } from "../../utils/trpc";
 import { BaseService } from "../base/base.service";
 import type { BillingRepository } from "./billing.repository";
 export declare class BillingService extends BaseService<{
@@ -20,31 +22,8 @@ export declare class BillingService extends BaseService<{
             name?: string;
         };
     }): ServerResultAsync<boolean>;
-    getActiveSubscription({ user }: {
-        user: User;
-    }): Promise<ServerResult<{
-        id: string;
-        plan: string;
-        referenceId: string;
-        status: string;
-        stripeCustomerId?: string | null | undefined;
-        stripeSubscriptionId?: string | null | undefined;
-        periodStart?: Date | null | undefined;
-        periodEnd?: Date | null | undefined;
-        cancelAtPeriodEnd?: boolean | null | undefined;
-        cancelAt?: Date | null | undefined;
-        canceledAt?: Date | null | undefined;
-        seats?: number | null | undefined;
-        trialStart?: Date | null | undefined;
-        trialEnd?: Date | null | undefined;
-        priceId?: string | null | undefined;
-        interval?: string | null | undefined;
-        unitAmount?: number | null | undefined;
-        discounts?: string[] | null | undefined;
-    } | null>>;
-    listInvoices({ user }: {
-        user: User;
-    }): ServerResultAsync<Stripe.Invoice[]>;
+    getActiveSubscription(ctx: Context): ServerResultAsync<BillingSchema | null>;
+    listInvoices(ctx: Context): ServerResultAsync<Stripe.Invoice[]>;
     createCheckoutSession({ priceId }: {
         priceId: string;
     }, { user }: {

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BillingService = void 0;
 const neverthrow_1 = require("neverthrow");
-const base_service_1 = require("../base/base.service");
 const posthog_1 = require("../../utils/posthog");
+const base_service_1 = require("../base/base.service");
 const allowedEvents = [
     "checkout.session.completed",
     "customer.subscription.created",
@@ -72,13 +72,13 @@ class BillingService extends base_service_1.BaseService {
         }
         return (0, neverthrow_1.ok)(true);
     }
-    async getActiveSubscription({ user }) {
-        return this.repository.billing.getActiveSubscription(user.id);
+    async getActiveSubscription(ctx) {
+        return this.repository.billing.getActiveSubscription(ctx.actor.userId);
     }
-    async listInvoices({ user }) {
-        if (!user.stripeCustomerId)
+    async listInvoices(ctx) {
+        if (!ctx.user.stripeCustomerId)
             return this.error("NOT_FOUND", "User has no stripe customer id");
-        return this.repository.billing.listInvoices(user.stripeCustomerId);
+        return this.repository.billing.listInvoices(ctx.user.stripeCustomerId);
     }
     async createCheckoutSession({ priceId }, { user }) {
         let stripeCustomerId = user.stripeCustomerId;

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

@@ -1,7 +1,7 @@
-import type { BillingService } from "./billing.service";
 import { type TRPCMethods } from "../../utils/trpc";
+import type { BillingService } from "./billing.service";
 export declare function createBillingTRPC({ router, privateProcedure: procedure }: TRPCMethods, billingService: BillingService): import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../auth/auth.lib").Context;
+    ctx: import("../../utils/trpc").Context;
     meta: any;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     transformer: true;

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

@@ -5,13 +5,11 @@ const billing_schema_1 = require("@m5kdev/commons/modules/billing/billing.schema
 const trpc_1 = require("../../utils/trpc");
 function createBillingTRPC({ router, privateProcedure: procedure }, billingService) {
     return router({
-        getActiveSubscription: procedure
-            .output(billing_schema_1.billingSchema.nullable())
-            .query(async ({ ctx: { user } }) => {
-            return (0, trpc_1.handleTRPCResult)(await billingService.getActiveSubscription({ user }));
+        getActiveSubscription: procedure.output(billing_schema_1.billingSchema.nullable()).query(async ({ ctx }) => {
+            return (0, trpc_1.handleTRPCResult)(await billingService.getActiveSubscription(ctx));
         }),
-        listInvoices: procedure.query(async ({ ctx: { user } }) => {
-            return (0, trpc_1.handleTRPCResult)(await billingService.listInvoices({ user }));
+        listInvoices: procedure.query(async ({ ctx }) => {
+            return (0, trpc_1.handleTRPCResult)(await billingService.listInvoices(ctx));
         }),
     });
 }

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

@@ -1,7 +1,6 @@
 import type { User } from "../auth/auth.lib";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
-import type { ConnectDeleteInputSchema, ConnectListInputSchema } from "./connect.dto";
 import type { ConnectRepository } from "./connect.repository";
 import type { ConnectProvider } from "./connect.types";
 export declare class ConnectService extends BaseService<{
@@ -21,7 +20,6 @@ export declare class ConnectService extends BaseService<{
         updatedAt: Date | null;
         expiresAt: Date | null;
         userId: string;
-        parentId: string | null;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
@@ -32,6 +30,7 @@ export declare class ConnectService extends BaseService<{
         displayName: string | null;
         avatarUrl: string | null;
         tokenType: string | null;
+        parentId: string | null;
         metadataJson: unknown;
         revokedAt: Date | null;
         lastRefreshedAt: Date | null;
@@ -42,7 +41,6 @@ export declare class ConnectService extends BaseService<{
         updatedAt: Date | null;
         expiresAt: Date | null;
         userId: string;
-        parentId: string | null;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
@@ -53,13 +51,19 @@ export declare class ConnectService extends BaseService<{
         displayName: string | null;
         avatarUrl: string | null;
         tokenType: string | null;
+        parentId: string | null;
         metadataJson: unknown;
         revokedAt: Date | null;
         lastRefreshedAt: Date | null;
     }>>;
-    list(input: ConnectListInputSchema, { user }: {
-        user: User;
-    }): Promise<import("../base/base.dto").ServerResult<{
+    readonly list: import("../base/base.procedure").ServiceProcedure<{
+        providers?: string[] | undefined;
+        inactive?: boolean | undefined;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
         id: string;
         userId: string;
         provider: string;
@@ -79,10 +83,14 @@ export declare class ConnectService extends BaseService<{
         lastRefreshedAt: Date | null;
         createdAt: Date;
         updatedAt: Date | null;
-    }[]>>;
-    delete({ id }: ConnectDeleteInputSchema, { user }: {
-        user: User;
-    }): Promise<import("../base/base.dto").ServerResult<{
+    }[]>;
+    readonly delete: import("../base/base.procedure").ServiceProcedure<{
         id: string;
-    }>>;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+    }>;
 }

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

@@ -97,18 +97,20 @@ class ConnectService extends base_service_1.BaseService {
             return (0, neverthrow_1.ok)(updated.value);
         });
     }
-    async list(input, { user }) {
-        return this.repository.connect.list({ userId: user.id, ...input });
-    }
-    async delete({ id }, { user }) {
-        const connection = await this.repository.connect.findById(id);
+    list = this.procedure("connectList")
+        .requireAuth()
+        .handle(({ input, ctx }) => this.repository.connect.list({ userId: ctx.actor.userId, ...input }));
+    delete = this.procedure("connectDelete")
+        .requireAuth()
+        .handle(async ({ input, ctx }) => {
+        const connection = await this.repository.connect.findById(input.id);
         if (connection.isOk()) {
-            if (connection.value?.userId !== user.id) {
+            if (connection.value?.userId !== ctx.actor.userId) {
                 return this.error("FORBIDDEN", "Not your connection");
             }
-            return this.repository.connect.deleteById(id);
+            return this.repository.connect.deleteById(input.id);
         }
         return (0, neverthrow_1.err)(connection.error);
-    }
+    });
 }
 exports.ConnectService = ConnectService;

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

@@ -1,7 +1,7 @@
 import { type TRPCMethods } from "../../utils/trpc";
 import type { ConnectService } from "./connect.service";
 export declare function createConnectTRPC({ router, privateProcedure: procedure }: TRPCMethods, connectService: ConnectService): import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../auth/auth.lib").Context;
+    ctx: import("../../utils/trpc").Context;
     meta: any;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     transformer: true;
@@ -20,12 +20,12 @@ export declare function createConnectTRPC({ router, privateProcedure: procedure
             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,12 +1,11 @@
-import type { CreateRecurrenceSchema, DeleteRecurrenceRulesSchema, DeleteRecurrenceSchema, UpdateRecurrenceRulesSchema, UpdateRecurrenceSchema } from "@m5kdev/commons/modules/recurrence/recurrence.schema";
-import type { Context } from "../auth/auth.lib";
+import type { DeleteRecurrenceRulesSchema, DeleteRecurrenceSchema, UpdateRecurrenceRulesSchema, UpdateRecurrenceSchema } from "@m5kdev/commons/modules/recurrence/recurrence.schema";
 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>, Context> {
+}, Record<string, never>> {
     readonly list: import("../base/base.procedure").ServiceProcedure<{
         page?: number | undefined;
         limit?: number | undefined;
@@ -20,7 +19,11 @@ export declare class RecurrenceService extends BaseService<{
             valueTo?: string | undefined;
             endColumnId?: string | undefined;
         }[] | undefined;
-    }, Context, {
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
         rows: {
             id: string;
             name: string | null;
@@ -28,14 +31,41 @@ export declare class RecurrenceService extends BaseService<{
             updatedAt: Date;
             metadata: Record<string, any> | null;
             userId: string | null;
-            teamId: string | null;
             organizationId: string | null;
+            teamId: string | null;
             enabled: boolean;
             kind: string | null;
         }[];
         total: number;
     }>;
-    create(data: CreateRecurrenceSchema, ctx: Context): ServerResultAsync<CreateWithRulesResult>;
+    readonly create: import("../base/base.procedure").ServiceProcedure<{
+        name: string;
+        kind: string;
+        enabled: boolean;
+        recurrenceRules: {
+            interval: number;
+            freq: number;
+            bysetpos?: number | number[] | null | undefined;
+            bymonth?: number | number[] | null | undefined;
+            bymonthday?: number | number[] | null | undefined;
+            byyearday?: number | number[] | null | undefined;
+            byweekno?: number | number[] | null | undefined;
+            byweekday?: number | number[] | null | undefined;
+            byhour?: number | number[] | null | undefined;
+            byminute?: number | number[] | null | undefined;
+            bysecond?: number | number[] | null | undefined;
+            dtstart?: Date | null | undefined;
+            wkst?: number | null | undefined;
+            count?: number | null | undefined;
+            until?: Date | null | undefined;
+            tzid?: string | null | undefined;
+        }[];
+        metadata?: Record<string, unknown> | null | undefined;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, CreateWithRulesResult>;
     findById(id: string): ServerResultAsync<CreateWithRulesResult["recurrence"] | null>;
     update(data: UpdateRecurrenceSchema & {
         id: string;