@m5kdev/backend 0.5.0 → 0.7.0

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;
@@ -12,10 +12,10 @@ 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;

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

@@ -1,6 +1,4 @@
-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 { 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";
@@ -8,13 +6,66 @@ 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"][];
+    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;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        rows: {
+            id: string;
+            name: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            metadata: Record<string, any> | null;
+            userId: string | null;
+            organizationId: string | null;
+            teamId: string | null;
+            enabled: boolean;
+            kind: string | null;
+        }[];
         total: number;
     }>;
+    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;

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

@@ -31,23 +31,25 @@ function mapRuleToInsert(rule) {
     return out;
 }
 class RecurrenceService extends base_service_1.BaseService {
-    async create(data, ctx) {
+    list = this.procedure("list")
+        .addContextFilter(["user"])
+        .handle(({ input }) => this.repository.recurrence.queryList(input));
+    create = this.procedure("create")
+        .requireAuth()
+        .handle(({ input, ctx }) => {
+        const { actor } = ctx;
         const recurrenceData = {
-            name: data.name,
-            kind: data.kind,
-            enabled: data.enabled,
-            metadata: data.metadata ?? null,
-            userId: ctx.user?.id ?? null,
-            organizationId: ctx.session.activeOrganizationId ?? null,
-            teamId: ctx.session.activeTeamId ?? null,
+            name: input.name,
+            kind: input.kind,
+            enabled: input.enabled,
+            metadata: input.metadata ?? null,
+            userId: actor.userId,
+            organizationId: actor.organizationId,
+            teamId: actor.teamId,
         };
-        const rulesData = data.recurrenceRules.map(mapRuleToInsert);
+        const rulesData = input.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,7 +1,7 @@
-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;
+    ctx: import("../../utils/trpc").Context;
     meta: any;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     transformer: true;
@@ -15,7 +15,7 @@ export declare function createRecurrenceTRPC({ router, privateProcedure: procedu
             filters?: {
                 columnId: string;
                 type: "string" | "number" | "boolean" | "date" | "enum";
-                method: "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "on" | "between" | "before" | "after" | "oneOf" | "intersect" | "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/social/social.service.d.ts

@@ -1,3 +1,4 @@
+import type { RequiredServiceActor } from "../base/base.actor";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
 import type { ConnectRepository } from "../connect/connect.repository";
@@ -19,10 +20,8 @@ export declare class SocialService extends BaseService<{
         file: FileService;
     }, providers: SocialProvider[]);
     getProvider(id: string): SocialProvider | null;
-    postToProvider(providerId: string, input: SocialPostInput, { user }: {
-        user: {
-            id: string;
-        };
+    postToProvider(providerId: string, input: SocialPostInput, { actor }: {
+        actor: RequiredServiceActor<"user">;
     }): ServerResultAsync<SocialPostResult>;
     private ensureFreshConnection;
 }

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

@@ -12,14 +12,14 @@ class SocialService extends base_service_1.BaseService {
     getProvider(id) {
         return this.providers.get(id) ?? null;
     }
-    async postToProvider(providerId, input, { user }) {
+    async postToProvider(providerId, input, { actor }) {
         return this.throwableAsync(async () => {
             const provider = this.getProvider(providerId);
             if (!provider) {
                 return this.error("BAD_REQUEST", `Unknown provider: ${providerId}`);
             }
             const connectionResult = await this.repository.connect.list({
-                userId: user.id,
+                userId: actor.userId,
                 providers: [providerId],
             });
             if (connectionResult.isErr()) {
@@ -46,7 +46,7 @@ class SocialService extends base_service_1.BaseService {
             const result = await provider.post({
                 deps: { fileService: this.service.file },
                 context: {
-                    userId: user.id,
+                    userId: actor.userId,
                     connection: connection.value,
                     accessToken,
                 },

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

@@ -122,34 +122,35 @@ class TagRepository extends base_repository_1.BaseTableRepository {
         });
     }
     async listTaggings(input, tx) {
-        return this.throwableAsync(async () => {
-            const db = tx ?? this.orm;
-            const filters = [(0, drizzle_orm_1.eq)(this.schema.taggings.resourceType, input.resourceType)];
-            if (input.resourceIds?.length) {
-                filters.push((0, drizzle_orm_1.inArray)(this.schema.taggings.resourceId, input.resourceIds));
-            }
-            const rows = await db
-                .select()
-                .from(this.schema.taggings)
-                .where((0, drizzle_orm_1.and)(...filters));
-            return (0, neverthrow_1.ok)(rows);
-        });
+        const db = tx ?? this.orm;
+        const filters = [(0, drizzle_orm_1.eq)(this.schema.taggings.resourceType, input.resourceType)];
+        if (input.resourceIds?.length) {
+            filters.push((0, drizzle_orm_1.inArray)(this.schema.taggings.resourceId, input.resourceIds));
+        }
+        const rows = await this.throwableQuery(() => db
+            .select()
+            .from(this.schema.taggings)
+            .where((0, drizzle_orm_1.and)(...filters)));
+        if (rows.isErr())
+            return (0, neverthrow_1.err)(rows.error);
+        return (0, neverthrow_1.ok)(rows.value);
     }
     async list(input, tx) {
-        return this.throwableAsync(async () => {
-            const db = tx ?? this.orm;
-            const conditions = this.getConditionBuilder(this.table);
-            conditions.push((0, drizzle_orm_1.isNull)(this.table.deletedAt));
-            conditions.applyFilters(input);
-            if (input?.assignableTo) {
-                conditions.push(this.helpers.arrayContains(this.table.assignableTo, [input.assignableTo]));
-            }
-            const whereClause = conditions.join();
-            const rowsQuery = this.withSortingAndPagination(db.select().from(this.table).where(whereClause), input || {});
-            const countQuery = db.select({ count: (0, drizzle_orm_1.count)() }).from(this.table).where(whereClause);
-            const [rows, [totalResult]] = await Promise.all([rowsQuery, countQuery]);
-            return (0, neverthrow_1.ok)({ rows, total: totalResult?.count ?? 0 });
-        });
+        const db = tx ?? this.orm;
+        const conditions = this.getConditionBuilder(this.table);
+        conditions.push((0, drizzle_orm_1.isNull)(this.table.deletedAt));
+        conditions.applyFilters(input);
+        if (input?.assignableTo) {
+            conditions.push(this.helpers.arrayContains(this.table.assignableTo, [input.assignableTo]));
+        }
+        const whereClause = conditions.join();
+        const rowsQuery = this.withSortingAndPagination(db.select().from(this.table).where(whereClause), input || {});
+        const countQuery = db.select({ count: (0, drizzle_orm_1.count)() }).from(this.table).where(whereClause);
+        const countResult = await this.throwableQuery(() => Promise.all([rowsQuery, countQuery]));
+        if (countResult.isErr())
+            return (0, neverthrow_1.err)(countResult.error);
+        const [rows, [totalResult]] = countResult.value;
+        return (0, neverthrow_1.ok)({ rows, total: totalResult?.count ?? 0 });
     }
 }
 exports.TagRepository = TagRepository;

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

@@ -1,8 +1,6 @@
-import type { TagCreateSchema, TagDeleteSchema, TagLinkSchema, TagListInputSchema, TagListOutputSchema, TagListSchema, TagSchema, TagUpdateSchema } from "@m5kdev/commons/modules/tag/tag.schema";
-import type { User } from "../auth/auth.lib";
+import type { TagDeleteSchema, TagLinkSchema, TagListInputSchema, TagListOutputSchema, TagListSchema, TagSchema } from "@m5kdev/commons/modules/tag/tag.schema";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
-import type { TaggingSelectOutputResult, TagSelectOutputResult } from "./tag.dto";
 import type { TagRepository } from "./tag.repository";
 export declare class TagService extends BaseService<{
     tag: TagRepository;
@@ -18,20 +16,97 @@ export declare class TagService extends BaseService<{
         resourceType: string;
         resourceId: string;
     }[]>>;
-    create(data: TagCreateSchema, { user }: {
-        user: User;
-    }): Promise<TagSelectOutputResult>;
-    update(data: TagUpdateSchema, { user }: {
-        user: User;
-    }): Promise<TagSelectOutputResult>;
-    link(data: TagLinkSchema, { user }: {
-        user: User;
-    }): Promise<TaggingSelectOutputResult>;
+    readonly create: import("../base/base.procedure").ServiceProcedure<{
+        name: string;
+        color: string;
+        assignableTo: string[];
+        organizationId?: string | undefined;
+        teamId?: string | undefined;
+        resourceType?: string | undefined;
+        resourceId?: string | undefined;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        deletedAt: Date | null;
+        userId: string;
+        organizationId: string | null;
+        teamId: string | null;
+        name: string;
+        color: string | null;
+        type: string | null;
+        isEnabled: boolean;
+        parentId: string | null;
+        assignableTo: string[];
+    }>;
+    readonly update: import("../base/base.procedure").ServiceProcedure<{
+        id: string;
+        name?: string | undefined;
+        color?: string | undefined;
+        assignableTo?: string[] | undefined;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        deletedAt: Date | null;
+        userId: string;
+        organizationId: string | null;
+        teamId: string | null;
+        name: string;
+        color: string | null;
+        type: string | null;
+        isEnabled: boolean;
+        parentId: string | null;
+        assignableTo: string[];
+    }>;
+    readonly link: import("../base/base.procedure").ServiceProcedure<{
+        tagId: string;
+        resourceType: string;
+        resourceId: string;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+        createdAt: Date;
+        tagId: string;
+        resourceType: string;
+        resourceId: string;
+    }>;
     linkBulk(data: TagLinkSchema[]): ServerResultAsync<TagSchema[]>;
     set(data: TagLinkSchema[]): ServerResultAsync<TagSchema[]>;
-    unlink(data: TagLinkSchema, { user }: {
-        user: User;
-    }): Promise<TagSelectOutputResult>;
+    readonly unlink: import("../base/base.procedure").ServiceProcedure<{
+        tagId: string;
+        resourceType: string;
+        resourceId: string;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        deletedAt: Date | null;
+        userId: string;
+        organizationId: string | null;
+        teamId: string | null;
+        name: string;
+        color: string | null;
+        type: string | null;
+        isEnabled: boolean;
+        parentId: string | null;
+        assignableTo: string[];
+    }>;
     delete(data: TagDeleteSchema): ServerResultAsync<{
         id: string;
     }>;

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

@@ -9,24 +9,32 @@ class TagService extends base_service_1.BaseService {
     async listTaggings(input) {
         return this.repository.tag.listTaggings(input);
     }
-    async create(data, { user }) {
-        return this.repository.tag.create({ ...data, userId: user.id });
-    }
-    async update(data, { user }) {
-        return this.repository.tag.update({ ...data, userId: user.id });
-    }
-    async link(data, { user }) {
-        return this.repository.tag.link({ ...data, userId: user.id });
-    }
+    create = this.procedure("create")
+        .requireAuth()
+        .handle(({ input, ctx }) => {
+        return this.repository.tag.create({ ...input, userId: ctx.actor.userId });
+    });
+    update = this.procedure("update")
+        .requireAuth()
+        .handle(({ input, ctx }) => {
+        return this.repository.tag.update({ ...input, userId: ctx.actor.userId });
+    });
+    link = this.procedure("link")
+        .requireAuth()
+        .handle(({ input, ctx }) => {
+        return this.repository.tag.link({ ...input, userId: ctx.actor.userId });
+    });
     async linkBulk(data) {
         return this.repository.tag.linkBulk(data);
     }
     async set(data) {
         return this.repository.tag.set(data);
     }
-    async unlink(data, { user }) {
-        return this.repository.tag.unlink({ ...data, userId: user.id });
-    }
+    unlink = this.procedure("unlink")
+        .requireAuth()
+        .handle(({ input, ctx }) => {
+        return this.repository.tag.unlink({ ...input, userId: ctx.actor.userId });
+    });
     async delete(data) {
         return this.repository.tag.softDeleteById(data.id);
     }

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

@@ -1,7 +1,7 @@
 import { type TRPCMethods } from "../../utils/trpc";
 import type { TagService } from "./tag.service";
 export declare function createTagTRPC({ router, privateProcedure: procedure }: TRPCMethods, tagService: TagService): import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../auth/auth.lib").Context;
+    ctx: import("../../utils/trpc").Context;
     meta: any;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     transformer: true;
@@ -15,7 +15,7 @@ export declare function createTagTRPC({ router, privateProcedure: procedure }: T
             filters?: {
                 columnId: string;
                 type: "string" | "number" | "boolean" | "date" | "enum";
-                method: "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "on" | "between" | "before" | "after" | "oneOf" | "intersect" | "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;
@@ -48,7 +48,7 @@ export declare function createTagTRPC({ router, privateProcedure: procedure }: T
             resourceIds?: {
                 columnId: string;
                 type: "string" | "number" | "boolean" | "date" | "enum";
-                method: "contains" | "equals" | "starts_with" | "ends_with" | "greater_than" | "less_than" | "on" | "between" | "before" | "after" | "oneOf" | "intersect" | "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/workflow/workflow.service.d.ts

@@ -1,18 +1,58 @@
-import type { WorkflowListInputSchema, WorkflowListOutputSchema, WorkflowReadInputSchema, WorkflowReadOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
+import type { WorkflowReadOutputSchema } from "@m5kdev/commons/modules/workflow/workflow.schema";
 import type { Job } from "bullmq";
-import type { User } from "../auth/auth.lib";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
 import type { WorkflowRepository } from "./workflow.repository";
 export declare class WorkflowService extends BaseService<{
     workflow: WorkflowRepository;
 }, never> {
-    read(input: WorkflowReadInputSchema, { user }: {
-        user: User;
-    }): ServerResultAsync<WorkflowReadOutputSchema>;
-    list(input: WorkflowListInputSchema, { user }: {
-        user: User;
-    }): ServerResultAsync<WorkflowListOutputSchema>;
+    readonly read: import("../base/base.procedure").ServiceProcedure<{
+        jobId: string;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+        userId: string | null;
+        jobId: string;
+        jobName: string;
+        queueName: string;
+        tags: string[] | null;
+        input: unknown;
+        output: unknown;
+        status: "queued" | "running" | "completed" | "failed";
+        error: string | null;
+        retries: number;
+        finishedAt: Date | null;
+        processedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    readonly list: import("../base/base.procedure").ServiceProcedure<{
+        status?: ("queued" | "running" | "completed" | "failed")[] | undefined;
+        jobName?: string | undefined;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+        userId: string | null;
+        jobId: string;
+        jobName: string;
+        queueName: string;
+        tags: string[] | null;
+        input: unknown;
+        output: unknown;
+        status: "queued" | "running" | "completed" | "failed";
+        error: string | null;
+        retries: number;
+        finishedAt: Date | null;
+        processedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[]>;
     added(params: Parameters<WorkflowRepository["added"]>[0]): ServerResultAsync<WorkflowReadOutputSchema>;
     addedMany(params: Parameters<WorkflowRepository["addedMany"]>[0]): ServerResultAsync<WorkflowReadOutputSchema[]>;
     started(job: Job): ServerResultAsync<WorkflowReadOutputSchema>;

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

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkflowService = void 0;
 const base_service_1 = require("../base/base.service");
 class WorkflowService extends base_service_1.BaseService {
-    async read(input, { user }) {
-        return await this.repository.workflow.read({ ...input, userId: user.id });
-    }
-    async list(input, { user }) {
-        return await this.repository.workflow.list({ ...input, userId: user.id });
-    }
+    read = this.procedure("workflowRead")
+        .requireAuth()
+        .handle(({ input, ctx }) => this.repository.workflow.read({ ...input, userId: ctx.actor.userId }));
+    list = this.procedure("workflowList")
+        .requireAuth()
+        .handle(({ input, ctx }) => this.repository.workflow.list({ ...input, userId: ctx.actor.userId }));
     async added(params) {
         return this.repository.workflow.added(params);
     }

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

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