@getstrata/bootstrap 0.1.0

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 = "core.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

@@ -0,0 +1,38 @@
+{
+  "name": "@getstrata/bootstrap",
+  "version": "0.1.0",
+  "description": "Strata application bootstrap — HttpKernel, DI, web session helpers",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EyK-26/strata.git",
+    "directory": "packages/strata-bootstrap"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/bootstrap/public-api.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/bootstrap/public-api.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun run build:bundle && bun run build:types",
+    "build:bundle": "bun build index.ts --outdir dist --target bun --external bun --external eta --external @getstrata/core",
+    "build:types": "tsc -p tsconfig.types.json",
+    "prepublishOnly": "bun run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@getstrata/core": "^0.3.0",
+    "typescript": "^5.9.0"
+  }
+}