@getstrata/core 0.2.0 → 0.3.2

package/dist/core/metrics/prometheus.d.ts

@@ -0,0 +1,26 @@
+interface MetricLabels {
+    method: string;
+    path: string;
+    status: string;
+}
+declare class PrometheusRegistry {
+    private readonly httpRequestsTotal;
+    private readonly httpRequestDurationMs;
+    incrementHttpRequest(labels: MetricLabels): void;
+    observeHttpDuration(labels: MetricLabels, durationMs: number): void;
+    renderMetrics(): string;
+    resetForTests(): void;
+    getHttpRequestSummary(): {
+        totalRequests: number;
+        byStatus: Record<string, number>;
+        topPaths: Array<{
+            method: string;
+            path: string;
+            count: number;
+        }>;
+    };
+    private metricKey;
+}
+declare const prometheusRegistry: PrometheusRegistry;
+export type { MetricLabels };
+export { PrometheusRegistry, prometheusRegistry };

package/dist/core/pagination/index.d.ts

@@ -0,0 +1,17 @@
+interface PaginationMeta {
+    page: number;
+    per_page: number;
+    total: number;
+    last_page: number;
+}
+interface PaginatedResult<T> {
+    data: T[];
+    meta: PaginationMeta;
+}
+declare function buildPaginationMeta(input: {
+    page: number;
+    perPage: number;
+    total: number;
+}): PaginationMeta;
+export type { PaginatedResult, PaginationMeta };
+export { buildPaginationMeta };

package/dist/core/queue/index.d.ts

@@ -0,0 +1,19 @@
+type QueuePriority = "high" | "default" | "low";
+declare abstract class Job<TPayload extends object = object> {
+    readonly maxAttempts?: number;
+    readonly backoffMs?: number;
+    readonly priority?: QueuePriority;
+    abstract handle(payload: TPayload): Promise<void>;
+}
+interface Queue {
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare class SyncQueue implements Queue {
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare class AsyncQueue implements Queue {
+    dispatch<TPayload extends object>(job: Job<TPayload>, payload: TPayload): Promise<void>;
+}
+declare function createQueue(driver: "sync" | "async"): Queue;
+export type { Queue, QueuePriority };
+export { AsyncQueue, createQueue, Job, SyncQueue };

package/dist/core/security/publicReads.d.ts

@@ -0,0 +1,3 @@
+declare function isPublicReadsEnabled(): boolean;
+declare function guestCanViewResource(): boolean;
+export { guestCanViewResource, isPublicReadsEnabled };

package/dist/core/security/securityEvents.d.ts

@@ -0,0 +1,6 @@
+interface SecurityEventDetails {
+    [key: string]: unknown;
+}
+declare function logSecurityEvent(event: string, details?: SecurityEventDetails): void;
+export type { SecurityEventDetails };
+export { logSecurityEvent };

package/dist/core/security/tokenExpiry.d.ts

@@ -0,0 +1,2 @@
+declare function resolveDefaultTokenExpiryDays(): number | null;
+export { resolveDefaultTokenExpiryDays };

package/dist/core/security/totp.d.ts

@@ -0,0 +1,3 @@
+declare function generateTotp(secret: string, counter: number, digits?: number): string;
+declare function verifyTotp(secret: string, token: string, window?: number): boolean;
+export { generateTotp, verifyTotp };

package/dist/core/storage/storage.d.ts

@@ -0,0 +1,41 @@
+import { S3Client } from "bun";
+interface StorageDriver {
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+interface S3StorageConfig {
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucket: string;
+    region?: string;
+    endpoint?: string;
+}
+declare class LocalStorageDriver implements StorageDriver {
+    private readonly rootDirectory;
+    constructor(rootDirectory: string);
+    private resolvePath;
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+declare class S3StorageDriver implements StorageDriver {
+    private readonly client;
+    constructor(client: S3Client);
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+declare class StorageManager {
+    private readonly driver;
+    constructor(driver: StorageDriver);
+    put(path: string, contents: string | Uint8Array): Promise<string>;
+    get(path: string): Promise<Uint8Array | null>;
+    delete(path: string): Promise<boolean>;
+}
+declare function resolveS3Config(): S3StorageConfig;
+declare function createS3Client(config?: S3StorageConfig): S3Client;
+declare function createStorageDriver(): StorageDriver;
+declare function storage(): StorageManager;
+export type { S3StorageConfig, StorageDriver };
+export { createS3Client, createStorageDriver, LocalStorageDriver, resolveS3Config, S3StorageDriver, StorageManager, storage, };

package/dist/core/tenant/databaseTenantContext.d.ts

@@ -0,0 +1,2 @@
+declare function runWithMigrationBypass<T>(callback: () => T | Promise<T>): Promise<T>;
+export { runWithMigrationBypass };

package/dist/core/tenant/resolveTenant.d.ts

@@ -0,0 +1,3 @@
+import type { TenantContext } from "./tenantContext";
+declare function resolveTenant(tenantId: number): Promise<TenantContext | null>;
+export { resolveTenant };

package/dist/core/tenant/tenantContext.d.ts

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+type TenantContext = {
+    id: number;
+    slug: string;
+    plan: "free" | "pro" | "enterprise";
+    region: "eu" | "us" | "apac";
+};
+declare const tenantContext: AsyncLocalStorage<TenantContext>;
+declare function runWithTenant<T>(tenant: TenantContext, callback: () => T | Promise<T>): T | Promise<T>;
+declare function currentTenant(): TenantContext | null;
+declare function currentTenantId(): number;
+declare function rateLimitMultiplierForPlan(plan: TenantContext["plan"]): number;
+export type { TenantContext };
+export { currentTenant, currentTenantId, rateLimitMultiplierForPlan, runWithTenant, tenantContext };

package/dist/core/tenant/tenantDatabaseScope.d.ts

@@ -0,0 +1,7 @@
+import { type TenantContext } from "./tenantContext";
+type TransactionHandle = {
+    unsafe(query: string, params?: readonly unknown[]): Promise<unknown[]>;
+};
+declare function applyTenantContextToTransaction(transaction: TransactionHandle, tenantId: number): Promise<void>;
+declare function runWithTenantDatabase<T>(tenant: TenantContext, callback: () => T | Promise<T>): Promise<T>;
+export { applyTenantContextToTransaction, runWithTenantDatabase };

package/dist/core/tenant/tenantMiddleware.d.ts

@@ -0,0 +1,6 @@
+import type { TenantContext } from "./tenantContext";
+declare const DEFAULT_TENANT: TenantContext;
+declare function resolveUserTenantId(userId: number): Promise<number>;
+declare function auditChecksum(payload: Record<string, unknown>): string;
+declare function createTenantMiddleware(): (request: Request, next: () => Promise<Response>) => Promise<Response>;
+export { auditChecksum, createTenantMiddleware, DEFAULT_TENANT, resolveUserTenantId };

package/dist/core/tracing/otel.d.ts

@@ -0,0 +1,26 @@
+interface OtelSpan {
+    traceId: string;
+    spanId: string;
+    name: string;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes: Array<{
+        key: string;
+        value: {
+            stringValue: string;
+        };
+    }>;
+    status: {
+        code: number;
+    };
+}
+declare function createSpan(input: {
+    traceId: string;
+    name: string;
+    startedAt: number;
+    endedAt: number;
+    attributes?: Record<string, string>;
+}): OtelSpan;
+declare function exportOtelSpan(span: OtelSpan): Promise<void>;
+export type { OtelSpan };
+export { createSpan, exportOtelSpan };

package/dist/core/tracing/traceContext.d.ts

@@ -0,0 +1,10 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+type TraceContext = {
+    traceId: string;
+    spanId: string;
+};
+declare const traceContextStorage: AsyncLocalStorage<TraceContext>;
+declare function runWithTraceContext<T>(context: TraceContext, callback: () => T | Promise<T>): T | Promise<T>;
+declare function currentTraceId(): string | null;
+export type { TraceContext };
+export { currentTraceId, runWithTraceContext, traceContextStorage };

package/dist/core/tracing/tracingMiddleware.d.ts

@@ -0,0 +1,3 @@
+import type { Middleware } from "../http/middleware";
+declare function createTracingMiddleware(): Middleware;
+export { createTracingMiddleware };

package/dist/core/view/etaViewEngine.d.ts

@@ -0,0 +1,15 @@
+import type { ViewEngine } from "./viewEngine";
+declare const DEFAULT_VIEWS_DIRECTORY: string;
+declare const DEFAULT_LAYOUT = "layouts/app.eta";
+interface RenderOptions {
+    layout?: string | false;
+}
+type LayoutDataResolver = () => Promise<Record<string, unknown>>;
+declare class EtaViewEngine implements ViewEngine {
+    private readonly eta;
+    private readonly resolveLayoutData?;
+    constructor(viewsDirectory?: string, resolveLayoutData?: LayoutDataResolver);
+    render(name: string, data?: Record<string, unknown>, options?: RenderOptions): Promise<string>;
+}
+export type { RenderOptions };
+export { DEFAULT_LAYOUT, DEFAULT_VIEWS_DIRECTORY, EtaViewEngine };

package/dist/core/view/htmlResponse.d.ts

@@ -0,0 +1,6 @@
+declare function htmlResponse(html: string, init?: {
+    status?: number;
+    statusText?: string;
+}): Response;
+declare function isHtmxRequest(request: Request): boolean;
+export { htmlResponse, isHtmxRequest };

package/dist/core/view/index.d.ts

@@ -0,0 +1,5 @@
+export { DEFAULT_VIEWS_DIRECTORY, EtaViewEngine } from "./etaViewEngine";
+export { htmlResponse, isHtmxRequest } from "./htmlResponse";
+export type { ViewEngine } from "./viewEngine";
+export type { WebLayoutAuthUser, WebLayoutData } from "./webLayoutData";
+export { resolveWebLayoutData } from "./webLayoutData";

package/dist/core/view/viewEngine.d.ts

@@ -0,0 +1,6 @@
+interface ViewEngine {
+    render(name: string, data?: Record<string, unknown>, options?: {
+        layout?: string | false;
+    }): Promise<string>;
+}
+export type { ViewEngine };

package/dist/core/view/webLayoutData.d.ts

@@ -0,0 +1,17 @@
+import type { ServiceContainer } from "../../bootstrap/contracts";
+interface WebLayoutAuthUser {
+    id: number;
+    email: string;
+    role: string;
+}
+interface WebLayoutData {
+    authUser: WebLayoutAuthUser | null;
+    csrfToken: string;
+    flash: {
+        level: string;
+        message: string;
+    } | null;
+}
+declare function resolveWebLayoutData(container: ServiceContainer, request?: Request): Promise<Record<string, unknown>>;
+export type { WebLayoutAuthUser, WebLayoutData };
+export { resolveWebLayoutData };

package/dist/db/connection/createConnection.d.ts

@@ -0,0 +1,6 @@
+import { SQL } from "bun";
+import type { DatabaseConfig } from "../../config/database";
+type DatabaseConnection = InstanceType<typeof SQL>;
+declare function createDatabaseConnection(config: DatabaseConfig): DatabaseConnection;
+export type { DatabaseConnection };
+export { createDatabaseConnection };

package/dist/db/connection/index.d.ts

@@ -0,0 +1,11 @@
+import { type DatabaseConnection } from "./createConnection";
+declare function getDatabase(): DatabaseConnection;
+declare function pingDatabase(connection?: DatabaseConnection): Promise<boolean>;
+declare function ensureDatabaseConnection(): Promise<DatabaseConnection>;
+declare function closeDatabase(): Promise<void>;
+declare function replaceDatabaseConnectionForTests(connection?: DatabaseConnection): Promise<void>;
+declare function resetDatabaseConnectionForTests(connection: DatabaseConnection): void;
+declare const db: Bun.SQL;
+export default db;
+export type { DatabaseConnection };
+export { closeDatabase, ensureDatabaseConnection, getDatabase, pingDatabase, replaceDatabaseConnectionForTests, resetDatabaseConnectionForTests, };

package/dist/domain/abilities.d.ts

@@ -0,0 +1,5 @@
+declare const MEMBER_ABILITIES: readonly ["organizations:read", "projects:read", "projects:create", "tasks:read", "tasks:create", "comments:read", "comments:create", "attachments:read", "attachments:create", "auth:tokens:read", "auth:tokens:write"];
+declare const ADMIN_ABILITIES: readonly ["organizations:read", "projects:read", "projects:create", "tasks:read", "tasks:create", "comments:read", "comments:create", "attachments:read", "attachments:create", "auth:tokens:read", "auth:tokens:write", "organizations:create", "organizations:update", "organizations:delete", "projects:update", "projects:delete", "tasks:update", "tasks:delete", "comments:update", "comments:delete", "attachments:delete", "webhooks:read", "webhooks:write", "audit:read"];
+declare const PLATFORM_ADMIN_ABILITIES: readonly ["*"];
+declare function resolveAbilitiesForRole(role: string | null | undefined): string[];
+export { ADMIN_ABILITIES, MEMBER_ABILITIES, PLATFORM_ADMIN_ABILITIES, resolveAbilitiesForRole };

package/dist/domain/auth.d.ts

@@ -0,0 +1,4 @@
+export declare const TEST_ADMIN_API_TOKEN = "workhub-admin-test-token";
+export declare const TEST_MEMBER_API_TOKEN = "workhub-member-test-token";
+export declare const USER_ROLES: readonly ["admin", "member"];
+export type UserRole = (typeof USER_ROLES)[number];

package/dist/framework/public-api.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Stable framework surface for application modules and future package extraction.
+ * Import from `@getstrata/core` (workspace) or `src/framework/public-api`.
+ */
+export type { ServiceProvider } from "../bootstrap/contracts";
+export { ConfigStore, resolveService, ServiceContainer, } from "../bootstrap/contracts";
+export type { AuthUser } from "../core/auth/authContext";
+export { currentAuthUser, runWithAuthUser } from "../core/auth/authContext";
+export { Policy } from "../core/auth/policy";
+export { default as CacheRepository } from "../core/cache/repository";
+export { CACHE_TAGS } from "../core/cache/tags";
+export type { DatabaseConnection } from "../core/database/baseRepository";
+export { default as BaseRepository } from "../core/database/baseRepository";
+export type { BelongsToRelation, HasManyRelation } from "../core/database/relationships";
+export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "../core/database/relationships";
+export { RepositoryQuery } from "../core/database/repositoryQuery";
+export { defineTable } from "../core/database/table";
+export type { QueryOptions, QueryOrder, QueryWhere, } from "../core/database/types";
+export { BadRequestError, ConflictError, ForbiddenError, NotFoundError, PreconditionFailedError, UnauthorizedError, UnprocessableEntityError, ValidationError, } from "../core/errors/http";
+export { EventBus } from "../core/events/eventBus";
+export { auth, cache, config, events, log, mail, policyGate, queue, storage, } from "../core/facades";
+export { createdResponse, jsonResponse, noContentResponse, paginatedResponse, parsePaginationQuery, securedBindRouteModel, withErrorHandling, } from "../core/http";
+export { assertIfMatch, etagFromResource, isEtagEnabled, } from "../core/http/etag";
+export { FormRequest } from "../core/http/formRequest";
+export { createMetricsMiddleware, normalizeMetricPath } from "../core/http/metricsMiddleware";
+export type { Middleware, RouteHandler } from "../core/http/middleware";
+export { WebFormRequest } from "../core/http/webFormRequest";
+export type { MailDriver, MailMessage } from "../core/mail/mailer";
+export { LogMailDriver, Mailer, mailer } from "../core/mail/mailer";
+export type { MetricLabels } from "../core/metrics/prometheus";
+export { PrometheusRegistry, prometheusRegistry } from "../core/metrics/prometheus";
+export type { Queue, QueuePriority } from "../core/queue";
+export { AsyncQueue, createQueue, Job, SyncQueue } from "../core/queue";
+export type { StorageDriver } from "../core/storage/storage";
+export { LocalStorageDriver, StorageManager } from "../core/storage/storage";

package/dist/index.js

@@ -285,9 +285,12 @@ function createDatabaseConnection(config) {
 
 // ../../src/db/connection/index.ts
 var connectionHolder = {
-  connection: createDatabaseConnection(databaseConfig)
+  connection: null
 };
 function getDatabase() {
+  if (!connectionHolder.connection) {
+    connectionHolder.connection = createDatabaseConnection(databaseConfig);
+  }
   return connectionHolder.connection;
 }
 var POOL_CONNECTION_METHODS = new Set(["begin", "close", "connect"]);
@@ -530,11 +533,23 @@ function buildQueryWhereClause(table, options = {}) {
     params
   };
 }
+function isQueryOrder(value) {
+  return "column" in value;
+}
 function normalizeOrderBy(orderBy) {
   if (!orderBy) {
     return [];
   }
-  return Array.isArray(orderBy) ? orderBy : [orderBy];
+  if (Array.isArray(orderBy)) {
+    return orderBy;
+  }
+  if (isQueryOrder(orderBy)) {
+    return [orderBy];
+  }
+  return Object.entries(orderBy).map(([column, direction]) => ({
+    column,
+    direction
+  }));
 }
 function buildOrderByClause(tableName, orderBy) {
   const parts = normalizeOrderBy(orderBy).map(({ column, direction }) => {
@@ -684,6 +699,18 @@ function buildDeleteByIdQuery(table, id) {
 }
 
 // ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
+}
+function belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
   for (const parent of parents) {
@@ -715,6 +742,86 @@ function indexBelongsToRelation(children, parents, relation) {
   return result;
 }
 
+// ../../src/core/database/repositoryQuery.ts
+class RepositoryQuery {
+  repository;
+  whereClause;
+  queryOptions;
+  eagerLoads = [];
+  constructor(repository, whereClause = {}, queryOptions = {}) {
+    this.repository = repository;
+    this.whereClause = whereClause;
+    this.queryOptions = queryOptions;
+  }
+  where(where) {
+    this.whereClause = { ...this.whereClause, ...where };
+    return this;
+  }
+  orderBy(orderBy) {
+    this.queryOptions = { ...this.queryOptions, orderBy };
+    return this;
+  }
+  limit(limit) {
+    this.queryOptions = { ...this.queryOptions, limit };
+    return this;
+  }
+  withHasMany(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasMany",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withBelongsTo(as, relation, parentRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "belongsTo",
+      as,
+      relation,
+      repository: parentRepository,
+      options
+    });
+    return this;
+  }
+  async get() {
+    const rows = await this.repository.findAll({
+      ...this.queryOptions,
+      where: this.whereClause
+    });
+    return await this.attach(rows);
+  }
+  async first() {
+    const rows = await this.get();
+    return rows[0] ?? null;
+  }
+  async attach(rows) {
+    if (rows.length === 0 || this.eagerLoads.length === 0) {
+      return rows.map((row) => ({ ...row }));
+    }
+    let result = rows.map((row) => ({ ...row }));
+    for (const load of this.eagerLoads) {
+      if (load.kind === "hasMany") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+        }));
+        continue;
+      }
+      const relation = load.relation;
+      const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
+      result = result.map((row) => ({
+        ...row,
+        [load.as]: grouped.get(row[relation.foreignKey])
+      }));
+    }
+    return result;
+  }
+}
+
 // ../../src/core/database/baseRepository.ts
 class BaseRepository {
   table;
@@ -851,6 +958,12 @@ class BaseRepository {
     clone.connection = connection;
     return clone;
   }
+  getConnection() {
+    return this.connection;
+  }
+  query(where = {}) {
+    return new RepositoryQuery(this, where);
+  }
   async findWhere(where, options = {}) {
     return await this.findAll({ ...options, where });
   }
@@ -2148,6 +2261,9 @@ export {
   log,
   jsonResponse,
   isEtagEnabled,
+  indexHasManyRelation,
+  indexBelongsToRelation,
+  hasMany,
   events,
   etagFromResource,
   defineTable,
@@ -2157,6 +2273,7 @@ export {
   createMetricsMiddleware,
   config,
   cache,
+  belongsTo,
   auth,
   assertIfMatch,
   WebFormRequest,
@@ -2166,6 +2283,7 @@ export {
   SyncQueue,
   StorageManager,
   ServiceContainer,
+  RepositoryQuery,
   PrometheusRegistry,
   PreconditionFailedError,
   Policy,

package/dist/modules/organization/memberRepository.d.ts

@@ -0,0 +1,14 @@
+import type { OrganizationMemberRecord, OrganizationMemberRole } from "./memberTypes";
+declare class OrganizationMemberRepository {
+    constructor();
+    findMembership(userId: number, organizationId: number): Promise<OrganizationMemberRecord | null>;
+    listForUser(userId: number): Promise<OrganizationMemberRecord[]>;
+    listForOrganization(organizationId: number): Promise<OrganizationMemberRecord[]>;
+    addMember(input: {
+        organizationId: number;
+        userId: number;
+        role?: OrganizationMemberRole;
+    }): Promise<OrganizationMemberRecord>;
+    removeMember(organizationId: number, userId: number): Promise<boolean>;
+}
+export default OrganizationMemberRepository;

package/dist/modules/organization/memberTypes.d.ts

@@ -0,0 +1,9 @@
+type OrganizationMemberRole = "owner" | "admin" | "member";
+type OrganizationMemberRecord = {
+    id: number;
+    organization_id: number;
+    user_id: number;
+    role: OrganizationMemberRole;
+    created_at: Date;
+};
+export type { OrganizationMemberRecord, OrganizationMemberRole };

package/dist/modules/user/apiTokenRepository.d.ts

@@ -0,0 +1,8 @@
+import { BaseRepository } from "../../core/database";
+import type { ApiTokenRecord } from "./types";
+declare class ApiTokenRepository extends BaseRepository<ApiTokenRecord, "id"> {
+    constructor();
+    findByTokenHash(tokenHash: string): Promise<ApiTokenRecord | null>;
+    touchLastUsedAt(id: number): Promise<void>;
+}
+export default ApiTokenRepository;

package/dist/modules/user/apiTokenTable.d.ts

@@ -0,0 +1,3 @@
+import type { ApiTokenRecord } from "./types";
+declare const apiTokenTable: import("../../core/database").TableDefinition<ApiTokenRecord, "id">;
+export { apiTokenTable };

package/dist/modules/user/authService.d.ts

@@ -0,0 +1,23 @@
+import type { OAuthProvider } from "../../core/auth/oauth/types";
+import type OAuthIdentityRepository from "./oauthIdentityRepository";
+import type UserRepository from "./repository";
+import type TokenService from "./tokenService";
+import type { CreatedApiToken } from "./types";
+interface LoginOptions {
+    mfaCode?: string;
+}
+declare class AuthService {
+    private readonly users;
+    private readonly tokens;
+    private readonly oauthIdentities;
+    private readonly oauthProviders;
+    constructor(users: UserRepository, tokens: TokenService, oauthIdentities: OAuthIdentityRepository);
+    registerOAuthProvider(provider: OAuthProvider): void;
+    getOAuthProvider(name: string): OAuthProvider | undefined;
+    loginWithPassword(email: string, password: string, options?: LoginOptions): Promise<CreatedApiToken>;
+    loginWithOAuth(providerName: string, code: string): Promise<CreatedApiToken>;
+    buildOAuthAuthorizationUrl(providerName: string, state: string): string;
+    private findOrCreateOAuthUser;
+}
+export default AuthService;
+export type { LoginOptions };

package/dist/modules/user/notificationRepository.d.ts

@@ -0,0 +1,6 @@
+import { BaseRepository } from "../../core/database";
+import type { NotificationRecord } from "./notificationTypes";
+declare class NotificationRepository extends BaseRepository<NotificationRecord, "id"> {
+    constructor();
+}
+export default NotificationRepository;

package/dist/modules/user/notificationService.d.ts

@@ -0,0 +1,25 @@
+import type { PaginatedResult } from "../../core/pagination";
+import type NotificationRepository from "./notificationRepository";
+import type { NotificationRecord } from "./notificationTypes";
+interface CreateNotificationInput {
+    userId: number;
+    tenantId: number;
+    type: string;
+    title: string;
+    body: string;
+    data?: Record<string, unknown>;
+}
+declare class NotificationService {
+    private readonly repository;
+    constructor(repository: NotificationRepository);
+    listForUser(userId: number, options: {
+        page: number;
+        perPage: number;
+        unreadOnly?: boolean;
+    }): Promise<PaginatedResult<NotificationRecord>>;
+    markRead(userId: number, notificationId: number): Promise<NotificationRecord>;
+    markAllRead(userId: number): Promise<number>;
+    create(input: CreateNotificationInput): Promise<NotificationRecord>;
+}
+export default NotificationService;
+export type { CreateNotificationInput };

package/dist/modules/user/notificationTable.d.ts

@@ -0,0 +1,3 @@
+import type { NotificationRecord } from "./notificationTypes";
+declare const notificationTable: import("../../core/database").TableDefinition<NotificationRecord, "id">;
+export { notificationTable };

package/dist/modules/user/notificationTypes.d.ts

@@ -0,0 +1,12 @@
+interface NotificationRecord {
+    id: number;
+    user_id: number;
+    tenant_id: number;
+    type: string;
+    title: string;
+    body: string;
+    data: Record<string, unknown>;
+    read_at: Date | null;
+    created_at: Date;
+}
+export type { NotificationRecord };

package/dist/modules/user/oauthIdentityRepository.d.ts

@@ -0,0 +1,9 @@
+import { BaseRepository } from "../../core/database";
+import type { OAuthIdentityRecord } from "./types";
+declare const oauthIdentityTable: import("../../core/database").TableDefinition<OAuthIdentityRecord, "id">;
+declare class OAuthIdentityRepository extends BaseRepository<OAuthIdentityRecord, "id"> {
+    constructor();
+    findByProviderUser(provider: string, providerUserId: string): Promise<OAuthIdentityRecord | null>;
+}
+export default OAuthIdentityRepository;
+export { oauthIdentityTable };