@m5kdev/backend 0.5.0 → 0.6.0

package/dist/src/modules/auth/auth.lib.d.ts

@@ -3260,13 +3260,13 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
                     $Infer: {
                         body: ({
                             permission: {
-                                readonly user?: ("get" | "update" | "set-role" | "create" | "delete" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                readonly user?: ("get" | "set-role" | "create" | "update" | "delete" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
                                 readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                             };
                             permissions?: never | undefined;
                         } | {
                             permissions: {
-                                readonly user?: ("get" | "update" | "set-role" | "create" | "delete" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
+                                readonly user?: ("get" | "set-role" | "create" | "update" | "delete" | "list" | "ban" | "impersonate" | "set-password")[] | undefined;
                                 readonly session?: ("delete" | "list" | "revoke")[] | undefined;
                             };
                             permission?: never | undefined;
@@ -3528,7 +3528,7 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
                 id: string;
                 organizationId: string;
                 email: string;
-                role: "member" | "owner" | "admin";
+                role: "admin" | "member" | "owner";
                 status: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).InvitationStatus;
                 inviterId: string;
                 expiresAt: Date;
@@ -3538,7 +3538,7 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
             Member: {
                 id: string;
                 organizationId: string;
-                role: "member" | "owner" | "admin";
+                role: "admin" | "member" | "owner";
                 createdAt: Date;
                 userId: string;
                 teamId?: string | undefined | undefined;
@@ -3566,7 +3566,7 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
                 members: {
                     id: string;
                     organizationId: string;
-                    role: "member" | "owner" | "admin";
+                    role: "admin" | "member" | "owner";
                     createdAt: Date;
                     userId: string;
                     teamId?: string | undefined | undefined;
@@ -3581,7 +3581,7 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
                     id: string;
                     organizationId: string;
                     email: string;
-                    role: "member" | "owner" | "admin";
+                    role: "admin" | "member" | "owner";
                     status: import("better-auth/plugins", { with: { "resolution-mode": "import" } }).InvitationStatus;
                     inviterId: string;
                     expiresAt: Date;
@@ -4811,7 +4811,7 @@ export declare function createBetterAuth<O extends Orm, S extends Schema, E exte
     } | undefined;
     verification?: {
         modelName?: string;
-        fields?: Partial<Record<"value" | "createdAt" | "updatedAt" | "expiresAt" | "identifier", string>>;
+        fields?: Partial<Record<"createdAt" | "updatedAt" | "expiresAt" | "value" | "identifier", string>>;
         additionalFields?: {
             [key: string]: import("better-auth", { with: { "resolution-mode": "import" } }).DBFieldAttribute;
         };

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

@@ -49,10 +49,10 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         input: void;
         output: {
             id: string;
-            status: string;
             createdAt: Date;
             updatedAt: Date | null;
             expiresAt: Date | null;
+            status: string;
             claimUserId: string | null;
             claimedAt: Date | null;
             claimedEmail: string | null;
@@ -67,11 +67,11 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         output: {
             id: string;
             email: string;
-            url: string;
             createdAt: Date;
-            userId: string;
             expiresAt: Date | null;
+            userId: string;
             claimId: string;
+            url: string;
         };
         meta: any;
     }>;
@@ -82,11 +82,11 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         output: {
             id: string;
             email: string;
-            url: string;
             createdAt: Date;
-            userId: string;
             expiresAt: Date | null;
+            userId: string;
             claimId: string;
+            url: string;
         }[];
         meta: any;
     }>;
@@ -139,11 +139,11 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         input: void;
         output: {
             id: string;
-            email: string | null;
             name: string | null;
-            status: string;
+            email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
+            status: string;
         }[];
         meta: any;
     }>;
@@ -153,11 +153,11 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         };
         output: {
             id: string;
-            email: string | null;
             name: string | null;
-            status: string;
+            email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
+            status: string;
         };
         meta: any;
     }>;
@@ -184,11 +184,11 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         };
         output: {
             id: string;
-            email: string | null;
             name: string | null;
-            status: string;
+            email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
+            status: string;
         };
         meta: any;
     }>;
@@ -198,11 +198,11 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         };
         output: {
             id: string;
-            email: string | null;
             name: string | null;
-            status: string;
+            email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
+            status: string;
         };
         meta: any;
     }>;
@@ -212,11 +212,11 @@ export declare function createAuthTRPC({ router, publicProcedure, privateProcedu
         };
         output: {
             id: string;
-            email: string | null;
             name: string | null;
-            status: string;
+            email: string | null;
             createdAt: Date;
             updatedAt: Date | null;
+            status: string;
         };
         meta: any;
     }>;

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

@@ -1,8 +1,8 @@
 import type { TRPC_ERROR_CODE_KEY } from "@trpc/server";
-import type { ServerResult, ServerResultAsync } from "./base.dto";
-import type { ServerErrorLayer } from "./base.types";
 import { ServerError } from "../../utils/errors";
 import { logger } from "../../utils/logger";
+import type { ServerResult, ServerResultAsync } from "./base.dto";
+import type { ServerErrorLayer } from "./base.types";
 export declare abstract class Base {
     layer: ServerErrorLayer;
     logger: ReturnType<typeof logger.child>;
@@ -15,4 +15,5 @@ export declare abstract class Base {
     handleUnknownError(error: unknown): ServerError;
     throwable<T>(fn: () => ServerResult<T>): ServerResult<T>;
     throwableAsync<T>(fn: () => ServerResultAsync<T>): ServerResultAsync<T>;
+    throwablePromise<T>(fn: () => Promise<T>, errorHandler?: (error: unknown) => ServerError): ServerResultAsync<T>;
 }

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

@@ -43,11 +43,20 @@ class Base {
     }
     async throwableAsync(fn) {
         try {
-            return fn();
+            return await fn();
         }
         catch (error) {
             return (0, neverthrow_1.err)(this.handleUnknownError(error));
         }
     }
+    async throwablePromise(fn, errorHandler) {
+        try {
+            const result = await fn();
+            return (0, neverthrow_1.ok)(result);
+        }
+        catch (error) {
+            return (0, neverthrow_1.err)(errorHandler ? errorHandler(error) : this.handleUnknownError(error));
+        }
+    }
 }
 exports.Base = Base;

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

@@ -0,0 +1,112 @@
+import type { QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
+import type { TRPC_ERROR_CODE_KEY } from "@trpc/server";
+import type { ServerError } from "../../utils/errors";
+import type { logger } from "../../utils/logger";
+import type { Context, Session, User } from "../auth/auth.lib";
+import type { Base } from "./base.abstract";
+import type { ServerResult, ServerResultAsync } from "./base.dto";
+import type { Entity, ResourceActionGrant } from "./base.grants";
+type ServiceLogger = ReturnType<typeof logger.child>;
+type RepositoryMap = Record<string, Base>;
+type ServiceMap = Record<string, Base>;
+export type ServiceProcedureContext = {
+    user?: User | null;
+    session?: Session | null;
+} & Record<string, unknown>;
+export type ServiceProcedureState = Record<string, unknown>;
+export type ServiceProcedureStoredValue<T> = [T] extends [undefined] ? undefined : Awaited<T>;
+export type ServiceProcedureResultLike<T> = T | ServerResult<T> | Promise<T | ServerResult<T>>;
+export type ServiceProcedureContextFilterScope = "user" | "organization" | "team";
+export type ServiceProcedureContextFilteredInput<TInput> = Extract<NonNullable<TInput>, QueryInput>;
+export type ServiceProcedure<TInput, TCtx extends ServiceProcedureContext, TOutput> = (input: TInput, ctx: TCtx) => ServerResultAsync<TOutput>;
+export type ServiceProcedureArgs<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState> = {
+    input: TInput;
+    ctx: TCtx;
+    state: State;
+    repository: Repositories;
+    service: Services;
+    logger: ServiceLogger;
+};
+export type ServiceProcedureStep<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TOutput = undefined> = (args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<ServiceProcedureStoredValue<TOutput>>;
+export type ServiceProcedureInputMapper<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TNextInput> = (args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<ServiceProcedureStoredValue<TNextInput>>;
+export type ServiceProcedureHandler<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TOutput> = (args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<TOutput>;
+export type ServiceProcedureEntityResolver<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TEntities extends Entity | Entity[] | undefined> = TEntities | ((args: ServiceProcedureArgs<TInput, TCtx, Repositories, Services, State>) => ServiceProcedureResultLike<TEntities>);
+type ServiceProcedureAccessBaseConfig = {
+    action: string;
+    grants?: ResourceActionGrant[];
+};
+export type ServiceProcedureEntityStepName<State extends ServiceProcedureState> = Extract<{
+    [Key in keyof State]: State[Key] extends Entity | Entity[] | undefined ? Key : never;
+}[keyof State], string>;
+export type ServiceProcedureAccessEntitiesConfig<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TEntities extends Entity | Entity[] | undefined = undefined> = ServiceProcedureAccessBaseConfig & {
+    entities?: ServiceProcedureEntityResolver<TInput, TCtx, Repositories, Services, State, TEntities>;
+    entityStep?: never;
+};
+export type ServiceProcedureAccessStateConfig<State extends ServiceProcedureState, StepName extends ServiceProcedureEntityStepName<State>> = ServiceProcedureAccessBaseConfig & {
+    entityStep: StepName;
+    entities?: never;
+};
+export type ServiceProcedureAccessConfig<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState, TEntities extends Entity | Entity[] | undefined = undefined> = ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State, TEntities> | ServiceProcedureAccessStateConfig<State, ServiceProcedureEntityStepName<State>>;
+export interface ServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>> {
+    use<StepName extends string, TOutput = void>(stepName: StepName, step: ServiceProcedureStep<TInput, TCtx, Repositories, Services, State, TOutput>): ServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TOutput>>>;
+    mapInput<StepName extends string, TNextInput>(stepName: StepName, step: ServiceProcedureInputMapper<TInput, TCtx, Repositories, Services, State, TNextInput>): ServiceProcedureBuilder<ServiceProcedureStoredValue<TNextInput>, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TNextInput>>>;
+    addContextFilter(include?: readonly ServiceProcedureContextFilterScope[]): ServiceProcedureBuilder<ServiceProcedureContextFilteredInput<TInput>, TCtx & Context, Repositories, Services, State & {
+        contextFilter: ServiceProcedureContextFilteredInput<TInput>;
+    }>;
+    requireAuth(): ServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State>;
+    handle<TOutput>(handler: ServiceProcedureHandler<TInput, TCtx, Repositories, Services, State, TOutput>): ServiceProcedure<TInput, TCtx, TOutput>;
+}
+export interface PermissionServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>> extends ServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State> {
+    use<StepName extends string, TOutput = void>(stepName: StepName, step: ServiceProcedureStep<TInput, TCtx, Repositories, Services, State, TOutput>): PermissionServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TOutput>>>;
+    mapInput<StepName extends string, TNextInput>(stepName: StepName, step: ServiceProcedureInputMapper<TInput, TCtx, Repositories, Services, State, TNextInput>): PermissionServiceProcedureBuilder<ServiceProcedureStoredValue<TNextInput>, TCtx, Repositories, Services, State & Record<StepName, ServiceProcedureStoredValue<TNextInput>>>;
+    addContextFilter(include?: readonly ServiceProcedureContextFilterScope[]): PermissionServiceProcedureBuilder<ServiceProcedureContextFilteredInput<TInput>, TCtx & Context, Repositories, Services, State & {
+        contextFilter: ServiceProcedureContextFilteredInput<TInput>;
+    }>;
+    requireAuth(): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State>;
+    access(config: ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State>): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State>;
+    access<TEntities extends Entity | Entity[] | undefined>(config: ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State, TEntities>): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State & {
+        access: TEntities;
+    }>;
+    access<StepName extends ServiceProcedureEntityStepName<State>>(config: ServiceProcedureAccessStateConfig<State, StepName>): PermissionServiceProcedureBuilder<TInput, TCtx & Context, Repositories, Services, State & {
+        access: State[StepName];
+    }>;
+}
+type BaseServiceProcedureHost<Repositories extends RepositoryMap, Services extends ServiceMap> = {
+    repository: Repositories;
+    service: Services;
+    logger: ServiceLogger;
+    addContextFilter(ctx: Context, include?: {
+        user?: boolean;
+        organization?: boolean;
+        team?: boolean;
+    }, query?: QueryInput): QueryInput;
+    error(code: TRPC_ERROR_CODE_KEY, message?: string, options?: {
+        cause?: unknown;
+        clientMessage?: string;
+        log?: boolean;
+    }): ServerResult<never>;
+    throwableAsync<T>(fn: () => ServerResultAsync<T>): ServerResultAsync<T>;
+    handleUnknownError(error: unknown): ServerError;
+};
+type PermissionServiceProcedureHost<Repositories extends RepositoryMap, Services extends ServiceMap> = BaseServiceProcedureHost<Repositories, Services> & {
+    checkPermission<T extends Entity>(ctx: {
+        session: Session;
+        user: User;
+    }, action: string, entities?: T | T[], grants?: ResourceActionGrant[]): boolean;
+    checkPermissionAsync<T extends Entity>(ctx: {
+        session: Session;
+        user: User;
+    }, action: string, getEntities: () => ServerResultAsync<T | T[] | undefined>, grants?: ResourceActionGrant[]): ServerResultAsync<boolean>;
+};
+type ProcedureRuntimeStep<Repositories extends RepositoryMap, Services extends ServiceMap> = {
+    stage: "use" | "input" | "auth" | "access";
+    stepName: string;
+    run: (args: ServiceProcedureArgs<unknown, ServiceProcedureContext, Repositories, Services, ServiceProcedureState>) => Promise<ServerResult<unknown>>;
+};
+type ProcedureBuilderConfig<Repositories extends RepositoryMap, Services extends ServiceMap> = {
+    name: string;
+    steps: ProcedureRuntimeStep<Repositories, Services>[];
+};
+export declare function createServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>>(host: BaseServiceProcedureHost<Repositories, Services>, config: ProcedureBuilderConfig<Repositories, Services>): ServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State>;
+export declare function createPermissionServiceProcedureBuilder<TInput, TCtx extends ServiceProcedureContext, Repositories extends RepositoryMap, Services extends ServiceMap, State extends ServiceProcedureState = Record<string, never>>(host: PermissionServiceProcedureHost<Repositories, Services>, config: ProcedureBuilderConfig<Repositories, Services>): PermissionServiceProcedureBuilder<TInput, TCtx, Repositories, Services, State>;
+export {};

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

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServiceProcedureBuilder = createServiceProcedureBuilder;
+exports.createPermissionServiceProcedureBuilder = createPermissionServiceProcedureBuilder;
+const neverthrow_1 = require("neverthrow");
+const DEFAULT_CONTEXT_FILTER_INCLUDE = [
+    "user",
+];
+function isServerResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "isErr" in value &&
+        typeof value.isErr === "function" &&
+        "isOk" in value &&
+        typeof value.isOk === "function");
+}
+async function normalizeProcedureResult(result) {
+    const resolved = await result;
+    return isServerResult(resolved) ? resolved : (0, neverthrow_1.ok)(resolved);
+}
+function assertUniqueStepName(steps, stepName) {
+    if (steps.some((step) => step.stepName === stepName)) {
+        throw new Error(`Duplicate service procedure step name: ${stepName}`);
+    }
+}
+function hasStepName(steps, stepName) {
+    return steps.some((step) => step.stepName === stepName);
+}
+function getContextFilterInclude(include = DEFAULT_CONTEXT_FILTER_INCLUDE) {
+    return {
+        user: include.includes("user"),
+        organization: include.includes("organization"),
+        team: include.includes("team"),
+    };
+}
+function getFailureStage(code) {
+    return code === "FORBIDDEN" || code === "UNAUTHORIZED" ? "forbidden" : "error";
+}
+function logProcedureStage(host, procedureName, ctx, stage, { stepName, durationMs, errorCode, } = {}) {
+    host.logger.debug({
+        procedureName,
+        stage,
+        stepName,
+        durationMs,
+        errorCode,
+        hasUser: Boolean(ctx.user),
+        hasSession: Boolean(ctx.session),
+    });
+}
+function createRequireAuthStep(host) {
+    return {
+        stage: "auth",
+        stepName: "auth",
+        run: async ({ ctx }) => {
+            if (!ctx.user || !ctx.session) {
+                return host.error("UNAUTHORIZED", "Unauthorized");
+            }
+            return (0, neverthrow_1.ok)(true);
+        },
+    };
+}
+function createUseStep(stepName, step) {
+    return {
+        stage: "use",
+        stepName,
+        run: async (args) => normalizeProcedureResult(step(args)),
+    };
+}
+function createInputStep(stepName, step) {
+    return {
+        stage: "input",
+        stepName,
+        run: async (args) => normalizeProcedureResult(step(args)),
+    };
+}
+function createContextFilterStep(host, include) {
+    const contextInclude = getContextFilterInclude(include);
+    return {
+        stage: "input",
+        stepName: "contextFilter",
+        run: async ({ input, ctx }) => (0, neverthrow_1.ok)(host.addContextFilter(ctx, contextInclude, input)),
+    };
+}
+function createAccessStep(host, config) {
+    return {
+        stage: "access",
+        stepName: "access",
+        run: async (args) => {
+            const typedArgs = args;
+            if (!typedArgs.ctx.user || !typedArgs.ctx.session) {
+                return host.error("UNAUTHORIZED", "Unauthorized");
+            }
+            const permissionContext = {
+                user: typedArgs.ctx.user,
+                session: typedArgs.ctx.session,
+            };
+            if ("entityStep" in config && typeof config.entityStep === "string") {
+                const entities = typedArgs.state[config.entityStep];
+                const hasPermission = host.checkPermission(permissionContext, config.action, entities, config.grants);
+                if (!hasPermission) {
+                    return host.error("FORBIDDEN");
+                }
+                return (0, neverthrow_1.ok)(entities);
+            }
+            if (typeof config.entities === "function") {
+                const resolveEntities = config.entities;
+                let loadedEntities;
+                const permission = await host.checkPermissionAsync(permissionContext, config.action, async () => {
+                    const entityResult = await normalizeProcedureResult(resolveEntities(typedArgs));
+                    if (entityResult.isOk()) {
+                        loadedEntities = entityResult.value;
+                    }
+                    return entityResult;
+                }, config.grants);
+                if (permission.isErr()) {
+                    return permission;
+                }
+                if (!permission.value) {
+                    return host.error("FORBIDDEN");
+                }
+                return (0, neverthrow_1.ok)(loadedEntities);
+            }
+            const entities = config.entities;
+            const hasPermission = host.checkPermission(permissionContext, config.action, entities, config.grants);
+            if (!hasPermission) {
+                return host.error("FORBIDDEN");
+            }
+            return (0, neverthrow_1.ok)(entities);
+        },
+    };
+}
+function createProcedureHandler(host, config, handler) {
+    return async (input, ctx) => host.throwableAsync(async () => {
+        const state = {};
+        const startTime = Date.now();
+        const typedCtx = ctx;
+        let currentInput = input;
+        logProcedureStage(host, config.name, typedCtx, "start");
+        try {
+            for (const step of config.steps) {
+                const stepResult = await step.run({
+                    input: currentInput,
+                    ctx: typedCtx,
+                    state,
+                    repository: host.repository,
+                    service: host.service,
+                    logger: host.logger,
+                });
+                if (stepResult.isErr()) {
+                    logProcedureStage(host, config.name, typedCtx, getFailureStage(stepResult.error.code), {
+                        stepName: step.stepName,
+                        durationMs: Date.now() - startTime,
+                        errorCode: stepResult.error.code,
+                    });
+                    return stepResult;
+                }
+                state[step.stepName] = stepResult.value;
+                if (step.stage === "input") {
+                    currentInput = stepResult.value;
+                }
+                if (step.stage === "auth") {
+                    logProcedureStage(host, config.name, typedCtx, "auth_passed", {
+                        stepName: step.stepName,
+                    });
+                }
+                if (step.stage === "access") {
+                    logProcedureStage(host, config.name, typedCtx, "access_passed", {
+                        stepName: step.stepName,
+                    });
+                }
+            }
+            const handlerResult = await normalizeProcedureResult(handler({
+                input: currentInput,
+                ctx: ctx,
+                state: state,
+                repository: host.repository,
+                service: host.service,
+                logger: host.logger,
+            }));
+            if (handlerResult.isErr()) {
+                logProcedureStage(host, config.name, typedCtx, getFailureStage(handlerResult.error.code), {
+                    durationMs: Date.now() - startTime,
+                    errorCode: handlerResult.error.code,
+                });
+                return handlerResult;
+            }
+            logProcedureStage(host, config.name, typedCtx, "success", {
+                durationMs: Date.now() - startTime,
+            });
+            return handlerResult;
+        }
+        catch (error) {
+            const serverError = host.handleUnknownError(error);
+            logProcedureStage(host, config.name, typedCtx, getFailureStage(serverError.code), {
+                durationMs: Date.now() - startTime,
+                errorCode: serverError.code,
+            });
+            throw error;
+        }
+    });
+}
+function createServiceProcedureBuilder(host, config) {
+    function addContextFilter(include) {
+        const steps = hasStepName(config.steps, "auth")
+            ? config.steps
+            : [...config.steps, createRequireAuthStep(host)];
+        assertUniqueStepName(steps, "contextFilter");
+        return createServiceProcedureBuilder(host, {
+            ...config,
+            steps: [...steps, createContextFilterStep(host, include)],
+        });
+    }
+    const builder = {
+        use(stepName, step) {
+            assertUniqueStepName(config.steps, stepName);
+            return createServiceProcedureBuilder(host, {
+                ...config,
+                steps: [...config.steps, createUseStep(stepName, step)],
+            });
+        },
+        mapInput(stepName, step) {
+            assertUniqueStepName(config.steps, stepName);
+            return createServiceProcedureBuilder(host, {
+                ...config,
+                steps: [...config.steps, createInputStep(stepName, step)],
+            });
+        },
+        addContextFilter,
+        requireAuth() {
+            assertUniqueStepName(config.steps, "auth");
+            return createServiceProcedureBuilder(host, {
+                ...config,
+                steps: [...config.steps, createRequireAuthStep(host)],
+            });
+        },
+        handle(handler) {
+            return createProcedureHandler(host, config, handler);
+        },
+    };
+    return builder;
+}
+function createPermissionServiceProcedureBuilder(host, config) {
+    function addContextFilter(include) {
+        const steps = hasStepName(config.steps, "auth")
+            ? config.steps
+            : [...config.steps, createRequireAuthStep(host)];
+        assertUniqueStepName(steps, "contextFilter");
+        return createPermissionServiceProcedureBuilder(host, {
+            ...config,
+            steps: [...steps, createContextFilterStep(host, include)],
+        });
+    }
+    function access(accessConfig) {
+        assertUniqueStepName(config.steps, "access");
+        return createPermissionServiceProcedureBuilder(host, {
+            ...config,
+            steps: [...config.steps, createAccessStep(host, accessConfig)],
+        });
+    }
+    const builder = {
+        use(stepName, step) {
+            assertUniqueStepName(config.steps, stepName);
+            return createPermissionServiceProcedureBuilder(host, {
+                ...config,
+                steps: [...config.steps, createUseStep(stepName, step)],
+            });
+        },
+        mapInput(stepName, step) {
+            assertUniqueStepName(config.steps, stepName);
+            return createPermissionServiceProcedureBuilder(host, {
+                ...config,
+                steps: [...config.steps, createInputStep(stepName, step)],
+            });
+        },
+        addContextFilter,
+        requireAuth() {
+            assertUniqueStepName(config.steps, "auth");
+            return createPermissionServiceProcedureBuilder(host, {
+                ...config,
+                steps: [...config.steps, createRequireAuthStep(host)],
+            });
+        },
+        access,
+        handle(handler) {
+            return createProcedureHandler(host, config, handler);
+        },
+    };
+    return builder;
+}

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

@@ -32,6 +32,7 @@ export declare class BaseRepository<O extends LibSQLDatabase<any>, S extends Rec
     getConditionBuilder(): ConditionBuilder;
     getConditionBuilder(table: undefined): ConditionBuilder;
     getConditionBuilder<TTable extends SQLiteTableWithColumns<any>>(table: TTable): TableConditionBuilder<TTable>;
+    throwableQuery<T>(fn: () => Promise<T>): ServerResultAsync<T>;
     withPagination<TQuery>(query: TQuery, { page, limit }: Pick<QueryInput, "page" | "limit">): TQuery;
     withSorting<TTable extends SQLiteTableWithColumns<any>, TQuery>(query: TQuery, { sort, order }: Pick<QueryInput, "sort" | "order">, table?: TTable): TQuery;
     withSortingAndPagination<TTable extends SQLiteTableWithColumns<any>, TQuery>(query: TQuery, { sort, order, page, limit }: Pick<QueryInput, "sort" | "order" | "page" | "limit">, table?: TTable): TQuery;

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

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseExternaRepository = exports.BaseTableRepository = exports.BaseRepository = exports.arrayContains = exports.TableConditionBuilder = exports.ConditionBuilder = void 0;
 const drizzle_orm_1 = require("drizzle-orm");
 const neverthrow_1 = require("neverthrow");
-const base_abstract_1 = require("./base.abstract");
-const base_dto_1 = require("./base.dto");
+const errors_1 = require("../../utils/errors");
 const applyPagination_1 = require("../utils/applyPagination");
 const applySorting_1 = require("../utils/applySorting");
 const getConditionsFromFilters_1 = require("../utils/getConditionsFromFilters");
+const base_abstract_1 = require("./base.abstract");
+const base_dto_1 = require("./base.dto");
 class ConditionBuilder {
     conditions;
     constructor(conditions = []) {
@@ -66,6 +67,15 @@ class BaseRepository extends base_abstract_1.Base {
         }
         return new TableConditionBuilder(table);
     }
+    throwableQuery(fn) {
+        return this.throwablePromise(() => fn(), (error) => new errors_1.ServerError({
+            code: "INTERNAL_SERVER_ERROR",
+            layer: "repository",
+            layerName: this.constructor.name,
+            message: "Database query failed",
+            cause: error,
+        }));
+    }
     withPagination(query, { page, limit }) {
         return (0, applyPagination_1.applyPagination)(query, limit, page);
     }