@m5kdev/backend 0.7.0 → 0.8.0

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

@@ -1,109 +0,0 @@
-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 { Base } from "./base.abstract";
-import { type Actor, type ActorScope, type AuthenticatedActor } from "./base.actor";
-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 = {
-    actor?: AuthenticatedActor | 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 = ActorScope;
-export type ServiceProcedureContextFilteredInput<TInput> = Extract<NonNullable<TInput>, QueryInput>;
-type ServiceProcedureAuthContext<Scope extends ActorScope> = {
-    actor: Actor[Scope];
-};
-type ServiceProcedureRequiredScopeFromFilter<TInclude extends readonly ServiceProcedureContextFilterScope[] | undefined> = TInclude extends readonly ServiceProcedureContextFilterScope[] ? "team" extends TInclude[number] ? "team" : "organization" extends TInclude[number] ? "organization" : "user" : "user";
-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<TInclude extends readonly ServiceProcedureContextFilterScope[] | undefined = undefined>(include?: TInclude): ServiceProcedureBuilder<ServiceProcedureContextFilteredInput<TInput>, TCtx & ServiceProcedureAuthContext<ServiceProcedureRequiredScopeFromFilter<TInclude>>, Repositories, Services, State & {
-        contextFilter: ServiceProcedureContextFilteredInput<TInput>;
-    }>;
-    requireAuth<Scope extends ActorScope = "user">(scope?: Scope): ServiceProcedureBuilder<TInput, TCtx & ServiceProcedureAuthContext<Scope>, 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<TInclude extends readonly ServiceProcedureContextFilterScope[] | undefined = undefined>(include?: TInclude): PermissionServiceProcedureBuilder<ServiceProcedureContextFilteredInput<TInput>, TCtx & ServiceProcedureAuthContext<ServiceProcedureRequiredScopeFromFilter<TInclude>>, Repositories, Services, State & {
-        contextFilter: ServiceProcedureContextFilteredInput<TInput>;
-    }>;
-    requireAuth<Scope extends ActorScope = "user">(scope?: Scope): PermissionServiceProcedureBuilder<TInput, TCtx & ServiceProcedureAuthContext<Scope>, Repositories, Services, State>;
-    access(config: ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State>): PermissionServiceProcedureBuilder<TInput, TCtx & ServiceProcedureAuthContext<"user">, Repositories, Services, State>;
-    access<TEntities extends Entity | Entity[] | undefined>(config: ServiceProcedureAccessEntitiesConfig<TInput, TCtx, Repositories, Services, State, TEntities>): PermissionServiceProcedureBuilder<TInput, TCtx & ServiceProcedureAuthContext<"user">, Repositories, Services, State & {
-        access: TEntities;
-    }>;
-    access<StepName extends ServiceProcedureEntityStepName<State>>(config: ServiceProcedureAccessStateConfig<State, StepName>): PermissionServiceProcedureBuilder<TInput, TCtx & ServiceProcedureAuthContext<"user">, Repositories, Services, State & {
-        access: State[StepName];
-    }>;
-}
-type BaseServiceProcedureHost<Repositories extends RepositoryMap, Services extends ServiceMap> = {
-    repository: Repositories;
-    service: Services;
-    logger: ServiceLogger;
-    addContextFilter(actor: AuthenticatedActor, 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>(actor: AuthenticatedActor, action: string, entities?: T | T[], grants?: ResourceActionGrant[]): boolean;
-    checkPermissionAsync<T extends Entity>(actor: AuthenticatedActor, 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

@@ -1,301 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createServiceProcedureBuilder = createServiceProcedureBuilder;
-exports.createPermissionServiceProcedureBuilder = createPermissionServiceProcedureBuilder;
-const neverthrow_1 = require("neverthrow");
-const base_actor_1 = require("./base.actor");
-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,
-        hasActor: Boolean(ctx.actor),
-    });
-}
-function requireProcedureActor(host, ctx, scope) {
-    if (!ctx.actor) {
-        return host.error("UNAUTHORIZED", "Unauthorized");
-    }
-    if (!(0, base_actor_1.validateActor)(ctx.actor, scope)) {
-        return host.error("FORBIDDEN", "Forbidden");
-    }
-    return (0, neverthrow_1.ok)(ctx.actor);
-}
-function createRequireAuthStep(host, scope = "user") {
-    return {
-        stage: "auth",
-        stepName: "auth",
-        run: async ({ ctx }) => {
-            return requireProcedureActor(host, ctx, scope);
-        },
-    };
-}
-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);
-    const requiredScope = contextInclude.team
-        ? "team"
-        : contextInclude.organization
-            ? "organization"
-            : "user";
-    return {
-        stage: "input",
-        stepName: "contextFilter",
-        run: async ({ input, ctx }) => {
-            const actor = requireProcedureActor(host, ctx, requiredScope);
-            if (actor.isErr())
-                return actor;
-            return (0, neverthrow_1.ok)(host.addContextFilter(actor.value, contextInclude, input));
-        },
-    };
-}
-function createAccessStep(host, config) {
-    return {
-        stage: "access",
-        stepName: "access",
-        run: async (args) => {
-            const typedArgs = args;
-            const actor = requireProcedureActor(host, typedArgs.ctx, "user");
-            if (actor.isErr())
-                return actor;
-            if ("entityStep" in config && typeof config.entityStep === "string") {
-                const entities = typedArgs.state[config.entityStep];
-                const hasPermission = host.checkPermission(actor.value, 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(actor.value, 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(actor.value, 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, "user")];
-        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(scope) {
-            assertUniqueStepName(config.steps, "auth");
-            return createServiceProcedureBuilder(host, {
-                ...config,
-                steps: [...config.steps, createRequireAuthStep(host, scope ?? "user")],
-            });
-        },
-        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, "user")];
-        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(scope) {
-            assertUniqueStepName(config.steps, "auth");
-            return createPermissionServiceProcedureBuilder(host, {
-                ...config,
-                steps: [...config.steps, createRequireAuthStep(host, scope ?? "user")],
-            });
-        },
-        access,
-        handle(handler) {
-            return createProcedureHandler(host, config, handler);
-        },
-    };
-    return builder;
-}

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

@@ -1,97 +0,0 @@
-import type { QueryFilters, QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
-import { type InferInsertModel, type InferSelectModel, type SelectedFields, type SQL } from "drizzle-orm";
-import type { LibSQLDatabase } from "drizzle-orm/libsql";
-import type { SQLiteColumn, SQLiteTableWithColumns } from "drizzle-orm/sqlite-core";
-import { Base } from "./base.abstract";
-import { pickColumns, type ServerResultAsync } from "./base.dto";
-/** Payload for update/updateMany: id key required (string), other table fields optional. */
-export type TableUpdatePayload<TTable extends SQLiteTableWithColumns<any>, TIdKey extends Extract<keyof InferSelectModel<TTable>, string> = "id"> = Record<TIdKey, string> & Partial<Omit<InferSelectModel<TTable>, TIdKey>>;
-export declare class ConditionBuilder {
-    private conditions;
-    constructor(conditions?: SQL[]);
-    push(condition?: SQL): void;
-    join(type?: "and" | "or"): SQL<unknown> | undefined;
-    [Symbol.iterator](): ArrayIterator<SQL<unknown>>;
-}
-export declare class TableConditionBuilder<TTable extends SQLiteTableWithColumns<any>> extends ConditionBuilder {
-    private table;
-    constructor(table: TTable);
-    applyFilters({ filters }?: {
-        filters?: QueryFilters;
-    }): void;
-}
-export declare const arrayContains: (table: SQLiteColumn, values: string[]) => SQL<unknown> | undefined;
-export declare class BaseRepository<O extends LibSQLDatabase<any>, S extends Record<string, SQLiteTableWithColumns<any>>, R extends Record<string, BaseRepository<any, any, any> | BaseExternaRepository>> extends Base {
-    protected orm: O;
-    protected schema: S;
-    repository?: R;
-    constructor(options: {
-        orm: O;
-        schema: S;
-    }, repository?: R);
-    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;
-    addUserIdFilter(userId: string, query?: QueryInput): QueryInput;
-    helpers: {
-        pickColumns: typeof pickColumns;
-        arrayContains: (table: SQLiteColumn, values: string[]) => SQL<unknown> | undefined;
-        ConditionBuilder: typeof ConditionBuilder;
-    };
-}
-/**
- * Generic table-bound repository with typed CRUD, returning ServerResultAsync via throwableAsync.
- *
- * Example:
- * const userRepo = new UserRepository(db, schema);
- * class UserRepository extends BaseTableRepository<typeof schema.user> {
- *   constructor(db: LibSQLDatabase<typeof schema>, schema: typeof schema) {
- *     super(db, schema, schema.user);
- *   }
- * }
- */
-export declare class BaseTableRepository<O extends LibSQLDatabase<any>, S extends Record<string, SQLiteTableWithColumns<any>>, R extends Record<string, BaseRepository<any, any, any> | BaseExternaRepository>, TTable extends SQLiteTableWithColumns<any>, TIdKey extends Extract<keyof InferSelectModel<TTable>, string> = "id"> extends BaseRepository<O, S, R> {
-    protected readonly table: TTable;
-    protected readonly idKey: TIdKey;
-    protected readonly idColumn: SQLiteColumn;
-    constructor(options: {
-        orm: O;
-        schema: S;
-        table: TTable;
-        idKey?: TIdKey;
-    }, repository?: R);
-    withSorting<TQuery>(query: TQuery, { sort, order }: Pick<QueryInput, "sort" | "order">, table?: SQLiteTableWithColumns<any>): TQuery;
-    withSortingAndPagination<MTable extends SQLiteTableWithColumns<any>, TQuery>(query: TQuery, { sort, order, page, limit }: Pick<QueryInput, "sort" | "order" | "page" | "limit">, table?: MTable): TQuery;
-    queryList(query?: QueryInput, options?: {
-        conditions?: TableConditionBuilder<TTable>;
-        select?: SelectedFields<SQLiteColumn, TTable>;
-    }, tx?: O): ServerResultAsync<{
-        rows: InferSelectModel<TTable>[];
-        total: number;
-    }>;
-    findById(id: string, tx?: O): ServerResultAsync<InferSelectModel<TTable> | undefined>;
-    findManyById(ids: readonly string[], tx?: O): ServerResultAsync<Array<InferSelectModel<TTable>>>;
-    create(data: InferInsertModel<TTable>, tx?: O): ServerResultAsync<InferSelectModel<TTable>>;
-    createMany(data: readonly InferInsertModel<TTable>[], tx?: O): ServerResultAsync<Array<InferSelectModel<TTable>>>;
-    update(data: TableUpdatePayload<TTable, TIdKey>, tx?: O): ServerResultAsync<InferSelectModel<TTable>>;
-    updateMany(data: readonly TableUpdatePayload<TTable, TIdKey>[], tx?: O): ServerResultAsync<Array<InferSelectModel<TTable>>>;
-    softDeleteById(id: string, tx?: O): ServerResultAsync<{
-        id: string;
-    }>;
-    softDeleteManyById(ids: readonly string[], tx?: O): ServerResultAsync<Array<{
-        id: string;
-    }>>;
-    deleteById(id: string, tx?: O): ServerResultAsync<{
-        id: string;
-    }>;
-    deleteManyById(ids: readonly string[], tx?: O): ServerResultAsync<Array<{
-        id: string;
-    }>>;
-}
-export declare class BaseExternaRepository extends Base {
-    constructor();
-}