@getstrata/core 0.2.0 → 0.3.0

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,30 @@
+/**
+ * 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 { default as BaseRepository } from "../core/database/baseRepository";
+export { defineTable } from "../core/database/table";
+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 }) => {

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 };

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

@@ -0,0 +1,11 @@
+import type { ServiceProvider } from "../../bootstrap/contracts";
+declare const userRepositoryToken = "user.repository";
+declare const apiTokenRepositoryToken = "user.apiTokenRepository";
+declare const tokenServiceToken = "user.tokenService";
+declare const authServiceToken = "user.authService";
+declare const oauthIdentityRepositoryToken = "user.oauthIdentityRepository";
+declare const notificationRepositoryToken = "user.notificationRepository";
+declare const notificationServiceToken = "user.notificationService";
+declare const userProvider: ServiceProvider;
+export default userProvider;
+export { apiTokenRepositoryToken, authServiceToken, notificationRepositoryToken, notificationServiceToken, oauthIdentityRepositoryToken, tokenServiceToken, userRepositoryToken, };

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

@@ -0,0 +1,12 @@
+import { BaseRepository } from "../../core/database";
+import type { UserRecord } from "./types";
+declare class UserRepository extends BaseRepository<UserRecord, "id"> {
+    constructor();
+    private decode;
+    findById(id: number): Promise<UserRecord | null>;
+    findAll(options?: Parameters<BaseRepository<UserRecord, "id">["findAll"]>[0]): Promise<UserRecord[]>;
+    create(values: Partial<UserRecord>): Promise<UserRecord>;
+    updateByIdOrThrow(id: number, values: Partial<UserRecord>, errorFactory?: (missingId: number) => Error): Promise<UserRecord>;
+    findByEmail(email: string): Promise<UserRecord | null>;
+}
+export default UserRepository;

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

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

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

@@ -0,0 +1,29 @@
+import type { AuthUser } from "../../core/auth/authContext";
+import type ApiTokenRepository from "./apiTokenRepository";
+import type UserRepository from "./repository";
+import type { ApiTokenRecord, ApiTokenResource, CreatedApiToken, UserRecord } from "./types";
+interface CreateTokenInput {
+    name: string;
+    abilities?: string[];
+    expiresAt?: Date | null;
+    expiresInDays?: number;
+}
+declare function toApiTokenResource(record: ApiTokenRecord): ApiTokenResource;
+declare function generatePlainTextToken(): string;
+declare function resolveExpiresAt(input: CreateTokenInput): Date | null;
+declare function normalizeAbilities(value: unknown): string[];
+declare class TokenService {
+    private readonly users;
+    private readonly tokens;
+    constructor(users: UserRepository, tokens: ApiTokenRepository);
+    resolveUserFromToken(token: string): Promise<AuthUser | null>;
+    createToken(userId: number, input: CreateTokenInput): Promise<CreatedApiToken>;
+    listTokensForUser(userId: number): Promise<ApiTokenResource[]>;
+    revokeToken(userId: number, tokenId: number): Promise<void>;
+    tokenCan(user: AuthUser | null, ability: string): boolean;
+    requireAbility(user: AuthUser | null, ability: string): void;
+    findByIdOrThrow(id: number): Promise<UserRecord>;
+    deleteUserAccount(userId: number): Promise<void>;
+}
+export default TokenService;
+export { generatePlainTextToken, normalizeAbilities, resolveExpiresAt, toApiTokenResource };

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

@@ -0,0 +1,46 @@
+import type { UserRole } from "../../domain/auth";
+interface UserRecord {
+    id: number;
+    name: string;
+    email: string;
+    email_lookup?: string | null;
+    role: UserRole;
+    tenant_id: number;
+    password_hash?: string | null;
+    email_verified_at?: Date | null;
+    mfa_secret?: string | null;
+    mfa_enabled?: boolean;
+    created_at: Date;
+    updated_at: Date;
+}
+interface OAuthIdentityRecord {
+    id: number;
+    user_id: number;
+    provider: string;
+    provider_user_id: string;
+    email: string | null;
+    created_at: Date;
+}
+interface ApiTokenRecord {
+    id: number;
+    user_id: number;
+    name: string;
+    token_hash: string;
+    abilities: string[];
+    last_used_at: Date | null;
+    expires_at: Date | null;
+    created_at: Date;
+}
+interface ApiTokenResource {
+    id: number;
+    name: string;
+    abilities: string[];
+    last_used_at: string | null;
+    expires_at: string | null;
+    created_at: string;
+}
+interface CreatedApiToken {
+    token: ApiTokenResource;
+    plainTextToken: string;
+}
+export type { ApiTokenRecord, ApiTokenResource, CreatedApiToken, OAuthIdentityRecord, UserRecord };

package/dist/types/services.d.ts

@@ -0,0 +1,16 @@
+interface CacheLike {
+    get<T>(key: string): Promise<T | undefined>;
+    remember<T>(key: string, callback: () => Promise<T>, ttlMs?: number): Promise<T>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<void>;
+    tags(...names: string[]): {
+        remember<T>(key: string, callback: () => Promise<T>, ttlMs?: number): Promise<T>;
+        flush(): Promise<number>;
+    };
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    invalidate(key: string): Promise<boolean>;
+    invalidateByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+}
+export type { CacheLike };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",
@@ -11,20 +11,21 @@
   },
   "exports": {
     ".": {
-      "types": "./index.ts",
+      "types": "./dist/framework/public-api.d.ts",
       "import": "./dist/index.js",
-      "default": "./index.ts"
+      "default": "./dist/index.js"
     }
   },
   "main": "./dist/index.js",
-  "types": "./index.ts",
+  "types": "./dist/framework/public-api.d.ts",
   "files": [
     "dist",
-    "index.ts",
     "README.md"
   ],
   "scripts": {
-    "build": "bun build index.ts --outdir dist --target bun --external bun --external eta",
+    "build": "bun run build:bundle && bun run build:types",
+    "build:bundle": "bun build index.ts --outdir dist --target bun --external bun --external eta",
+    "build:types": "tsc -p tsconfig.types.json",
     "prepublishOnly": "bun run build"
   },
   "publishConfig": {

package/index.ts

@@ -1 +0,0 @@
-export * from "../../src/framework/public-api";