@m5kdev/web-ui 0.8.6 → 0.8.8

package/dist/packages/backend/dist/src/modules/auth/auth.service.d.ts

@@ -0,0 +1,106 @@
+import { ServerResultAsync } from "../base/base.dto.js";
+import { BaseService } from "../base/base.service.js";
+import { BillingService } from "../billing/billing.service.js";
+import { EmailService } from "../email/email.service.js";
+import { Context } from "../../utils/trpc.js";
+import { AccountClaim, AccountClaimMagicLinkOutput, AccountClaimOutput, Waitlist, WaitlistOutput } from "./auth.dto.js";
+import { AuthRepository } from "./auth.repository.js";
+
+//#region ../backend/dist/src/modules/auth/auth.service.d.mts
+//#region src/modules/auth/auth.service.d.ts
+type AuthServiceDependencies = {
+  email: EmailService;
+} | {
+  email: EmailService;
+  billing: BillingService;
+};
+declare class AuthService extends BaseService<{
+  auth: AuthRepository;
+}, AuthServiceDependencies> {
+  private getBillingService;
+  private organizationActorFromCtx;
+  getUserWaitlistCount(ctx: Context): ServerResultAsync<number>;
+  getOnboarding(ctx: Context): ServerResultAsync<number>;
+  setOnboarding(onboarding: number, ctx: Context): ServerResultAsync<number>;
+  getPreferences(ctx: Context): ServerResultAsync<Record<string, unknown>>;
+  setPreferences(preferences: Record<string, unknown>, ctx: Context): ServerResultAsync<Record<string, unknown>>;
+  getOrganizationPreferences(ctx: Context): ServerResultAsync<Record<string, unknown>>;
+  setOrganizationPreferences(preferences: Record<string, unknown>, ctx: Context): ServerResultAsync<Record<string, unknown>>;
+  getMetadata(ctx: Context): ServerResultAsync<Record<string, unknown>>;
+  setMetadata(metadata: Record<string, unknown>, ctx: Context): ServerResultAsync<Record<string, unknown>>;
+  getFlags(ctx: Context): ServerResultAsync<string[]>;
+  getOrganizationFlags(ctx: Context): ServerResultAsync<string[]>;
+  setFlags(flags: string[], ctx: Context): ServerResultAsync<string[]>;
+  setOrganizationFlags(flags: string[], ctx: Context): ServerResultAsync<string[]>;
+  listAdminWaitlist(): ServerResultAsync<WaitlistOutput[]>;
+  listWaitlist(ctx: Context): ServerResultAsync<Waitlist[]>;
+  addToWaitlist({
+    email
+  }: {
+    email: string;
+  }): ServerResultAsync<WaitlistOutput>;
+  inviteFromWaitlist({
+    id
+  }: {
+    id: string;
+  }): ServerResultAsync<Waitlist>;
+  inviteToWaitlist({
+    email,
+    name
+  }: {
+    email: string;
+    name?: string;
+  }, ctx: Context): ServerResultAsync<Waitlist>;
+  createInvitationCode({
+    name
+  }: {
+    name?: string;
+  }, ctx: Context): ServerResultAsync<Waitlist>;
+  joinWaitlist({
+    email
+  }: {
+    email: string;
+  }): ServerResultAsync<WaitlistOutput>;
+  removeFromWaitlist({
+    id
+  }: {
+    id: string;
+  }): ServerResultAsync<WaitlistOutput>;
+  validateWaitlistCode(code: string): ServerResultAsync<{
+    status: string;
+  }>;
+  createAccountClaimCode({
+    userId,
+    expiresInHours
+  }: {
+    userId: string;
+    expiresInHours?: number;
+  }): ServerResultAsync<AccountClaim>;
+  listAccountClaims(): ServerResultAsync<AccountClaimOutput[]>;
+  getMyAccountClaimStatus(ctx: Context): ServerResultAsync<AccountClaim | null>;
+  setMyAccountClaimEmail({
+    email
+  }: {
+    email: string;
+  }, ctx: Context): ServerResultAsync<{
+    status: boolean;
+  }>;
+  acceptMyAccountClaim(ctx: Context): ServerResultAsync<{
+    status: boolean;
+  }>;
+  generateAccountClaimMagicLink({
+    claimId,
+    email
+  }: {
+    claimId: string;
+    email?: string;
+  }): ServerResultAsync<AccountClaimMagicLinkOutput>;
+  listAccountClaimMagicLinks({
+    claimId
+  }: {
+    claimId: string;
+  }): ServerResultAsync<AccountClaimMagicLinkOutput[]>;
+} //#endregion
+//#endregion
+export { AuthService };
+//# sourceMappingURL=auth.service.d.ts.map

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

@@ -0,0 +1,30 @@
+import { ServerErrorLayer } from "./base.types.js";
+import { TRPC_ERROR_CODE_KEY } from "../../../../../../node_modules/.pnpm/@trpc_server@11.4.3_typescript@5.9.2/node_modules/@trpc/server/dist/unstable-core-do-not-import.d-ClFRzVsT.js";
+import { ServerError } from "../../utils/errors.js";
+import { Err } from "../../../../../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.js";
+import { ServerResult, ServerResultAsync } from "./base.dto.js";
+import { logger } from "../../utils/logger.js";
+
+//#region ../backend/dist/src/modules/base/base.abstract.d.mts
+//#region src/modules/base/base.abstract.d.ts
+declare abstract class Base {
+  layer: ServerErrorLayer;
+  logger: ReturnType<typeof logger.child>;
+  constructor(layer: ServerErrorLayer);
+  error(code: TRPC_ERROR_CODE_KEY, message?: string, {
+    cause,
+    clientMessage,
+    log
+  }?: {
+    cause?: unknown;
+    clientMessage?: string;
+    log?: boolean;
+  }): Err<never, ServerError>;
+  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>;
+} //#endregion
+//#endregion
+export { Base };
+//# sourceMappingURL=base.abstract.d.ts.map

package/dist/packages/backend/dist/src/modules/base/base.actor.d.ts

@@ -0,0 +1,38 @@
+//#region ../backend/dist/src/modules/base/base.actor.d.mts
+//#region src/modules/base/base.actor.d.ts
+type UserActor = {
+  userId: string;
+  userRole: string;
+  organizationId: string | null;
+  organizationRole: string | null;
+  teamId: string | null;
+  teamRole: string | null;
+};
+type OrganizationActor = {
+  userId: string;
+  userRole: string;
+  organizationId: string;
+  organizationRole: string;
+  teamId: string | null;
+  teamRole: string | null;
+};
+type TeamActor = {
+  userId: string;
+  userRole: string;
+  organizationId: string;
+  organizationRole: string;
+  teamId: string;
+  teamRole: string;
+};
+type AuthenticatedActor = UserActor | OrganizationActor | TeamActor;
+/** @deprecated Prefer `AuthenticatedActor` — kept for grants and legacy call sites */
+type Actor = {
+  user: UserActor;
+  organization: OrganizationActor;
+  team: TeamActor;
+  authenticated: AuthenticatedActor;
+};
+type ActorScope = "user" | "organization" | "team";
+//#endregion
+export { Actor, ActorScope, AuthenticatedActor, UserActor };
+//# sourceMappingURL=base.actor.d.ts.map

package/dist/packages/backend/dist/src/modules/base/base.dto.d.ts

@@ -0,0 +1,13 @@
+import { ServerError } from "../../utils/errors.js";
+import { Table } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/table.js";
+import { getTableColumns } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/utils.js";
+import { Result } from "../../../../../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.js";
+import { z } from "zod";
+
+//#region ../backend/dist/src/modules/base/base.dto.d.mts
+type ServerResult<T> = Result<T, ServerError>;
+type ServerResultAsync<T> = Promise<ServerResult<T>>;
+declare function pickColumns<T extends Table, Shape extends z.ZodRawShape>(table: T, schema: z.ZodObject<Shape>): Pick<ReturnType<typeof getTableColumns<T>>, Extract<keyof Shape, string>>;
+//#endregion
+export { ServerResult, ServerResultAsync, pickColumns };
+//# sourceMappingURL=base.dto.d.ts.map

package/dist/packages/backend/dist/src/modules/base/base.grants.d.ts

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

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

@@ -0,0 +1,47 @@
+import { ServerResult, ServerResultAsync } from "./base.dto.js";
+import { logger } from "../../utils/logger.js";
+import { Base } from "./base.abstract.js";
+import { Actor, ActorScope, AuthenticatedActor } from "./base.actor.js";
+import { QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
+
+//#region ../backend/dist/src/modules/base/base.procedure.d.mts
+//#region src/modules/base/base.procedure.d.ts
+type ServiceLogger = ReturnType<typeof logger.child>;
+type RepositoryMap = Record<string, Base>;
+type ServiceMap = Record<string, Base>;
+type ServiceProcedureContext = {
+  actor?: AuthenticatedActor | null;
+} & Record<string, unknown>;
+type ServiceProcedureState = Record<string, unknown>;
+type ServiceProcedureStoredValue<T> = [T] extends [undefined] ? undefined : Awaited<T>;
+type ServiceProcedureResultLike<T> = T | ServerResult<T> | Promise<T | ServerResult<T>>;
+type ServiceProcedureContextFilterScope = ActorScope;
+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";
+type ServiceProcedure<TInput, TCtx extends ServiceProcedureContext, TOutput> = (input: TInput, ctx: TCtx) => ServerResultAsync<TOutput>;
+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;
+};
+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>>;
+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>>;
+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>;
+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>;
+}
+//#endregion
+export { ServiceProcedure, ServiceProcedureArgs, ServiceProcedureBuilder, ServiceProcedureContext, ServiceProcedureContextFilterScope, ServiceProcedureContextFilteredInput, ServiceProcedureInputMapper };
+//# sourceMappingURL=base.procedure.d.ts.map

package/dist/packages/backend/dist/src/modules/base/base.repository.d.mts

@@ -27,6 +27,7 @@ declare class TableConditionBuilder<TTable extends SQLiteTableWithColumns<any>>
   }?: {
     filters?: QueryFilters;
   }): void;
+  applyGlobalSearch(q: string | undefined, columns: readonly SQLiteColumn[]): void;
 }
 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;
@@ -95,6 +96,7 @@ declare class BaseTableRepository<O extends LibSQLDatabase<any>, S extends Recor
   queryList(query?: QueryInput, options?: {
     conditions?: TableConditionBuilder<TTable>;
     select?: SelectedFields<SQLiteColumn, TTable>;
+    globalSearchColumns?: string[];
   }, tx?: O): ServerResultAsync<{
     rows: InferSelectModel<TTable>[];
     total: number;

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

@@ -0,0 +1,128 @@
+import { InferInsertModel, InferSelectModel } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/table.js";
+import { SelectedFields } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/operations.js";
+import { SQL } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/sql/sql.js";
+import { SQLiteTableWithColumns } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/sqlite-core/table.js";
+import { SQLiteColumn } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/sqlite-core/columns/common.js";
+import { ServerResultAsync, pickColumns } from "./base.dto.js";
+import { Base } from "./base.abstract.js";
+import { LibSQLDatabase } from "../../../../../../node_modules/.pnpm/drizzle-orm@0.44.3_@libsql_client@0.17.0_bufferutil@4.1.0_utf-8-validate@5.0.10__@opent_ac1027c3f9e88da128946e54f6f618fa/node_modules/drizzle-orm/libsql/driver-core.js";
+import { QueryFilters, QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
+
+//#region ../backend/dist/src/modules/base/base.repository.d.mts
+//#region src/modules/base/base.repository.d.ts
+/** Payload for update/updateMany: id key required (string), other table fields optional. */
+type TableUpdatePayload<TTable extends SQLiteTableWithColumns<any>, TIdKey extends Extract<keyof InferSelectModel<TTable>, string> = "id"> = Record<TIdKey, string> & Partial<Omit<InferSelectModel<TTable>, TIdKey>>;
+declare class ConditionBuilder {
+  private conditions;
+  constructor(conditions?: SQL[]);
+  push(condition?: SQL): void;
+  join(type?: "and" | "or"): SQL<unknown> | undefined;
+  [Symbol.iterator](): ArrayIterator<SQL<unknown>>;
+}
+declare class TableConditionBuilder<TTable extends SQLiteTableWithColumns<any>> extends ConditionBuilder {
+  private table;
+  constructor(table: TTable);
+  applyFilters({
+    filters
+  }?: {
+    filters?: QueryFilters;
+  }): void;
+  applyGlobalSearch(q: string | undefined, columns: readonly SQLiteColumn[]): void;
+}
+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);
+ *   }
+ * }
+ */
+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>;
+    globalSearchColumns?: string[];
+  }, 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;
+  }>>;
+}
+declare class BaseExternaRepository extends Base {
+  constructor();
+} //#endregion
+//#endregion
+export { BaseRepository, BaseTableRepository };
+//# sourceMappingURL=base.repository.d.ts.map

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

@@ -0,0 +1,34 @@
+import { Base } from "./base.abstract.js";
+import { AuthenticatedActor } from "./base.actor.js";
+import { ServiceProcedure, ServiceProcedureArgs, ServiceProcedureBuilder, ServiceProcedureContext, ServiceProcedureContextFilterScope, ServiceProcedureContextFilteredInput, ServiceProcedureInputMapper } from "./base.procedure.js";
+import { QueryFilter, QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
+
+//#region ../backend/dist/src/modules/base/base.service.d.mts
+//#region src/modules/base/base.service.d.ts
+declare class BaseService<Repositories extends Record<string, Base>, Services extends Record<string, Base>, DefaultContext extends ServiceProcedureContext = ServiceProcedureContext> extends Base {
+  repository: Repositories;
+  service: Services;
+  constructor(repository?: Repositories, service?: Services);
+  addUserFilter(value: string, query?: undefined, columnId?: string, method?: QueryFilter["method"]): QueryInput;
+  addUserFilter<TQuery extends QueryInput>(value: string, query: TQuery, columnId?: string, method?: QueryFilter["method"]): TQuery;
+  protected procedure<TInput, TCtx extends ServiceProcedureContext = DefaultContext>(name: string): ServiceProcedureBuilder<TInput, TCtx, Repositories, Services>;
+  addContextFilter(actor: AuthenticatedActor, include?: {
+    user?: boolean;
+    organization?: boolean;
+    team?: boolean;
+  }, query?: undefined, map?: Record<string, {
+    columnId: string;
+    method: QueryFilter["method"];
+  }>): QueryInput;
+  addContextFilter<TQuery extends QueryInput>(actor: AuthenticatedActor, include: {
+    user?: boolean;
+    organization?: boolean;
+    team?: boolean;
+  } | undefined, query: TQuery, map?: Record<string, {
+    columnId: string;
+    method: QueryFilter["method"];
+  }>): TQuery;
+}
+//#endregion
+export { BaseService };
+//# sourceMappingURL=base.service.d.ts.map

package/dist/packages/backend/dist/src/modules/base/base.types.d.ts

@@ -0,0 +1,6 @@
+//#region ../backend/dist/src/modules/base/base.types.d.mts
+//#region src/modules/base/base.types.d.ts
+type ServerErrorLayer = "unknown" | "repository" | "service" | "controller" | "auth" | "workflow"; //#endregion
+//#endregion
+export { ServerErrorLayer };
+//# sourceMappingURL=base.types.d.ts.map

package/dist/packages/backend/dist/src/modules/billing/billing.repository.d.mts

@@ -2714,7 +2714,7 @@ declare const schema: {
 type Schema = typeof schema;
 type Orm = LibSQLDatabase<Schema>;
 declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["subscriptions"]> {
-  stripe: Stripe$1;
+  stripe: Stripe;
   plans: StripePlan[];
   trial?: StripePlan;
   constructor(options: {
@@ -2722,7 +2722,7 @@ declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<
     schema: Schema;
     table: Schema["subscriptions"];
     libs: {
-      stripe: Stripe$1;
+      stripe: Stripe;
     };
     config: {
       trial?: StripePlan;
@@ -2731,7 +2731,7 @@ declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<
   });
   hasTrial(): boolean;
   getPlanByPriceId(priceId: string): StripePlan | undefined;
-  getCustomerByEmail(email: string): ServerResultAsync<Stripe$1.Customer | null>;
+  getCustomerByEmail(email: string): ServerResultAsync<Stripe.Customer | null>;
   getUserByCustomerId(customerId: string): ServerResultAsync<InferSelectModel<Schema["users"]> | null>;
   createCustomer({
     email,
@@ -2741,8 +2741,8 @@ declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<
     email: string;
     name?: string;
     userId: string;
-  }): ServerResultAsync<Stripe$1.Customer>;
-  createTrialSubscription(customerId: string): ServerResultAsync<Stripe$1.Subscription>;
+  }): ServerResultAsync<Stripe.Customer>;
+  createTrialSubscription(customerId: string): ServerResultAsync<Stripe.Subscription>;
   createSubscription({
     customerId,
     priceId,
@@ -2753,7 +2753,7 @@ declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<
     priceId: string;
     quantity?: number;
     trialDays?: number;
-  }): ServerResultAsync<Stripe$1.Subscription>;
+  }): ServerResultAsync<Stripe.Subscription>;
   updateUserCustomerId({
     userId,
     customerId
@@ -2763,7 +2763,7 @@ declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<
   }): ServerResultAsync<InferSelectModel<Schema["users"]>>;
   getLatestSubscription(referenceId: string): ServerResultAsync<BillingSchema | null>;
   getActiveSubscription(referenceId: string): ServerResultAsync<BillingSchema | null>;
-  listInvoices(customerId: string): ServerResultAsync<Stripe$1.Invoice[]>;
+  listInvoices(customerId: string): ServerResultAsync<Stripe.Invoice[]>;
   createCheckoutSession({
     customerId,
     priceId,
@@ -2772,8 +2772,8 @@ declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<
     customerId: string;
     priceId: string;
     userId: string;
-  }): ServerResultAsync<Stripe$1.Checkout.Session>;
-  createBillingPortalSession(customerId: string): ServerResultAsync<Stripe$1.BillingPortal.Session>;
+  }): ServerResultAsync<Stripe.Checkout.Session>;
+  createBillingPortalSession(customerId: string): ServerResultAsync<Stripe.BillingPortal.Session>;
   syncStripeData({
     customerId,
     userId
@@ -2781,7 +2781,7 @@ declare class BillingRepository extends BaseTableRepository<Orm, Schema, Record<
     customerId: string;
     userId: string;
   }): ServerResultAsync<boolean>;
-  constructEvent(body: Buffer | string, signature: string, secret: string): ServerResult<Stripe$1.Event>;
+  constructEvent(body: Buffer | string, signature: string, secret: string): ServerResult<Stripe.Event>;
 } //#endregion
 //#endregion
 export { BillingRepository };