@getstrata/core 0.5.5 → 0.5.7

package/README.md

@@ -16,6 +16,7 @@ process.env.DATABASE_URL ??= "postgresql://postgres:postgres@localhost:5432/myap
 
 import {
   BaseRepository,
+  EtaViewEngine,
   FormRequest,
   Policy,
   mailer,
@@ -24,6 +25,8 @@ import {
 } from "@getstrata/core";
 ```
 
+**Dependency:** `eta` is bundled as a direct dependency of `@getstrata/core` — apps do not need to list it separately. The database driver is your app's choice — WorkHub and getstrata use **Bun's built-in `Bun.sql`** client; bind it with `bindDatabaseConnection()`.
+
 `orderBy` accepts explicit `{ column, direction }` objects or Laravel-style shorthand `{ published_at: "desc" }`.
 
 ## Build & verify (monorepo root)

package/dist/bootstrap/discoverModules.d.ts

@@ -0,0 +1,4 @@
+import type { AppModule } from "./contracts";
+declare const appModules: AppModule[];
+declare function discoverModules(): AppModule[];
+export { appModules, discoverModules };

package/dist/bootstrap/modules.d.ts

@@ -0,0 +1 @@
+export { appModules, discoverModules } from "./discoverModules";

package/dist/bootstrap/routeRegistry.d.ts

@@ -0,0 +1,14 @@
+interface RegisteredRoute {
+    method: string;
+    path: string;
+    middleware: string[];
+}
+declare class RouteRegistry {
+    private readonly routes;
+    register(route: RegisteredRoute): void;
+    clear(): void;
+    list(): RegisteredRoute[];
+}
+declare const routeRegistry: RouteRegistry;
+export type { RegisteredRoute };
+export { RouteRegistry, routeRegistry };

package/dist/core/audit/exportAuditLogs.d.ts

@@ -0,0 +1,8 @@
+interface AuditExportConfig {
+    endpoint: string;
+    format: "json" | "cef";
+    batchSize: number;
+}
+declare function resolveAuditExportConfig(): AuditExportConfig | null;
+declare function exportPendingAuditLogs(): Promise<number>;
+export { exportPendingAuditLogs, resolveAuditExportConfig };

package/dist/core/audit/siemFormatter.d.ts

@@ -0,0 +1,30 @@
+interface SiemAuditEvent {
+    timestamp: string;
+    event_type: string;
+    actor_user_id: number | null;
+    tenant_id: number | null;
+    trace_id: string | null;
+    action: string;
+    subject_type: string;
+    subject_id: number | null;
+    ip_address: string | null;
+    user_agent: string | null;
+    checksum: string | null;
+    payload: Record<string, unknown>;
+}
+declare function formatSiemAuditEvent(input: {
+    action: string;
+    subject_type: string;
+    subject_id: number | null;
+    user_id: number | null;
+    tenant_id?: number | null;
+    trace_id?: string | null;
+    ip_address?: string | null;
+    user_agent?: string | null;
+    checksum?: string | null;
+    payload?: Record<string, unknown>;
+    created_at: Date;
+}): SiemAuditEvent;
+declare function formatCefLine(event: SiemAuditEvent): string;
+export type { SiemAuditEvent };
+export { formatCefLine, formatSiemAuditEvent };

package/dist/core/auth/membershipScope.d.ts

@@ -0,0 +1,16 @@
+declare function resolveOrganizationScope(): number[] | null;
+declare function scopedOrganizationIds(requestedOrganizationId?: number): number[] | null;
+declare function appendOrganizationScope<T extends object>(where: T, requestedOrganizationId?: number): T;
+declare function appendProjectScope<T extends object>(where: T, accessibleProjectIds: number[] | null, requestedProjectId?: number): T;
+declare function emptyPaginateResult<T>(page: number, perPage: number): {
+    data: T[];
+    meta: {
+        page: number;
+        per_page: number;
+        total: number;
+        last_page: number;
+    };
+};
+declare function assertResourceInCurrentTenant(resourceTenantId: number, resourceLabel: string, resourceId: number): void;
+declare function assertOrganizationReadable(organizationId: number): void;
+export { appendOrganizationScope, appendProjectScope, assertOrganizationReadable, assertResourceInCurrentTenant, emptyPaginateResult, resolveOrganizationScope, scopedOrganizationIds, };

package/dist/core/auth/membershipService.d.ts

@@ -0,0 +1,20 @@
+import type { OrganizationMemberRole } from "../../modules/organization/memberTypes";
+import { type AuthUser } from "./authContext";
+declare class MembershipService {
+    constructor();
+    listOrganizationIdsForUser(userId: number): Promise<number[]>;
+    getOrgRole(userId: number, organizationId: number): Promise<OrganizationMemberRole | null>;
+    requireOrgAccess(organizationId: number, minimumRole?: OrganizationMemberRole, user?: AuthUser | null): Promise<OrganizationMemberRole>;
+    filterAccessibleOrganizationIds(organizationIds: number[], user?: AuthUser | null): Promise<number[]>;
+    addOwnerOnOrganizationCreate(organizationId: number, userId: number): Promise<void>;
+    listMembersForOrganization(organizationId: number): Promise<import("../../modules/organization/memberTypes").OrganizationMemberRecord[]>;
+    addMember(input: {
+        organizationId: number;
+        userId: number;
+        role?: OrganizationMemberRole;
+    }): Promise<import("../../modules/organization/memberTypes").OrganizationMemberRecord>;
+    removeMember(organizationId: number, userId: number): Promise<boolean>;
+}
+declare function resolveMembershipService(): MembershipService;
+export default MembershipService;
+export { resolveMembershipService };

package/dist/core/auth/scimAuthMiddleware.d.ts

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

package/dist/core/auth/sessionCookie.d.ts

@@ -0,0 +1,6 @@
+declare const SESSION_COOKIE = "workhub_session";
+declare const SESSION_TTL_SECONDS: number;
+declare function readSessionUserId(request: Request): number | null;
+declare function createSessionCookie(userId: number): string;
+declare function clearSessionCookie(): string;
+export { clearSessionCookie, createSessionCookie, readSessionUserId, SESSION_COOKIE, SESSION_TTL_SECONDS, };

package/dist/core/auth/sessionGuard.d.ts

@@ -0,0 +1,9 @@
+import type { ServiceContainer } from "../../bootstrap/contracts";
+import type { AuthUser } from "./authContext";
+import type { AuthGuard } from "./guard";
+declare class SessionGuard implements AuthGuard {
+    private readonly container;
+    constructor(container: ServiceContainer);
+    resolve(request: Request): Promise<AuthUser | null>;
+}
+export { SessionGuard };

package/dist/core/cache/createCacheStore.d.ts

@@ -0,0 +1,11 @@
+import type { CacheStore } from "./store";
+type CacheDriver = "array" | "redis";
+interface CreateCacheStoreOptions {
+    driver: CacheDriver;
+    ttlMs: number;
+    maxEntries: number;
+    redisUrl?: string;
+}
+declare function createCacheStore(options: CreateCacheStoreOptions): CacheStore;
+export type { CacheDriver, CreateCacheStoreOptions };
+export { createCacheStore };

package/dist/core/cache/keys.d.ts

@@ -0,0 +1,2 @@
+declare function buildCacheKey(namespace: string, ...parts: Array<string | number>): string;
+export { buildCacheKey };

package/dist/core/cache/modelCacheTags.d.ts

@@ -0,0 +1,3 @@
+declare function cacheTagsForModelWrite(tableName: string, action: string): string[];
+declare function discoverModelTableNames(): string[];
+export { cacheTagsForModelWrite, discoverModelTableNames };

package/dist/core/cache/redisCacheStore.d.ts

@@ -0,0 +1,23 @@
+import type { CacheStore } from "./store";
+declare class RedisCacheStore implements CacheStore {
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly client;
+    private readonly inflight;
+    private readonly keyTags;
+    constructor(redisUrl: string, ttlMs: number, maxEntries: number);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    attachTags(key: string, tags: string[]): Promise<void>;
+    flushTags(tags: string[]): Promise<number>;
+    invalidate(key: string): Promise<boolean>;
+    invalidateByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+    private storageKey;
+    private tagKey;
+    private detachKeyFromTags;
+    private enforceMaxEntries;
+}
+export default RedisCacheStore;

package/dist/core/cache/simpleCache.d.ts

@@ -0,0 +1,23 @@
+declare class SimpleCache {
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly cache;
+    private readonly inflight;
+    private readonly tagIndex;
+    private readonly keyTags;
+    constructor(ttlMs?: number, maxEntries?: number);
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T, ttlMs?: number): void;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    attachTags(key: string, tags: string[]): void;
+    flushTags(tags: string[]): number;
+    invalidate(key: string): boolean;
+    invalidateByPrefix(prefix: string): number;
+    clear(): void;
+    size(): number;
+    private detachKeyFromTags;
+    private getFreshEntry;
+    private pruneExpired;
+    private evictOverflow;
+}
+export default SimpleCache;

package/dist/core/cache/simpleCacheStore.d.ts

@@ -0,0 +1,16 @@
+import type SimpleCache from "./simpleCache";
+import type { CacheStore } from "./store";
+declare class SimpleCacheStore implements CacheStore {
+    private readonly cache;
+    constructor(cache: SimpleCache);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlMs?: number): Promise<T>;
+    attachTags(key: string, tags: string[]): Promise<void>;
+    flushTags(tags: string[]): Promise<number>;
+    invalidate(key: string): Promise<boolean>;
+    invalidateByPrefix(prefix: string): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+}
+export default SimpleCacheStore;

package/dist/core/config/envSchema.d.ts

@@ -0,0 +1,12 @@
+interface EnvRule {
+    required?: boolean;
+    integer?: boolean;
+    minimum?: number;
+    default?: string;
+    pattern?: RegExp;
+}
+type EnvSchema = Record<string, EnvRule>;
+declare function defineEnvSchema(schema: EnvSchema): EnvSchema;
+declare function validateEnv(schema: EnvSchema, env?: Record<string, string | undefined>): Record<string, string>;
+export type { EnvRule, EnvSchema };
+export { defineEnvSchema, validateEnv };

package/dist/core/crypto/nonCryptographicHash.d.ts

@@ -0,0 +1,2 @@
+declare function nonCryptographicDigest(input: string): string;
+export { nonCryptographicDigest };

package/dist/core/database/factory.d.ts

@@ -0,0 +1,6 @@
+declare class Factory<TRecord extends object> {
+    constructor();
+    protected definition(): TRecord;
+    make(overrides?: Partial<TRecord>): TRecord;
+}
+export { Factory };

package/dist/core/http/cookies.d.ts

@@ -0,0 +1,4 @@
+import type { BunRequest } from "bun";
+declare function readRequestCookie(request: Request, name: string): string | null;
+declare function readBunRequestCookie(request: BunRequest, name: string): string | null;
+export { readBunRequestCookie, readRequestCookie };

package/dist/core/http/csrfProtection.d.ts

@@ -0,0 +1,12 @@
+declare const DEFAULT_CSRF_TTL_MS: number;
+interface CsrfProtectionOptions {
+    expiresIn?: number;
+    maxAge?: number;
+}
+declare function createCsrfProtection(secret: string, options?: CsrfProtectionOptions): {
+    generate(_sessionKey?: string): string;
+    verify(token: string | undefined, _sessionKey?: string): boolean;
+    secret: string;
+};
+export type { CsrfProtectionOptions };
+export { createCsrfProtection, DEFAULT_CSRF_TTL_MS };

package/dist/core/http/scimThrottleMiddleware.d.ts

@@ -0,0 +1,9 @@
+import type { Middleware } from "./middleware";
+interface ScimThrottleOptions {
+    redisUrl?: string;
+    maxAttempts: number;
+    decaySeconds: number;
+}
+declare function createScimThrottleMiddleware(options: ScimThrottleOptions): Middleware;
+export type { ScimThrottleOptions };
+export { createScimThrottleMiddleware };

package/dist/core/jobs/dispatchWebhookJob.d.ts

@@ -0,0 +1,14 @@
+import { Job } from "../queue";
+interface DispatchWebhookPayload {
+    webhookId: number;
+    event: string;
+    payload: Record<string, unknown>;
+}
+declare class DispatchWebhookJob extends Job<DispatchWebhookPayload> {
+    constructor();
+    readonly maxAttempts = 3;
+    readonly backoffMs = 2000;
+    handle(payload: DispatchWebhookPayload): Promise<void>;
+}
+export default DispatchWebhookJob;
+export type { DispatchWebhookPayload };

package/dist/core/jobs/invalidateCacheTagsJob.d.ts

@@ -0,0 +1,12 @@
+import type { CacheLike } from "../../types/services";
+import { Job } from "../queue";
+interface InvalidateCacheTagsPayload {
+    tags: string[];
+}
+declare class InvalidateCacheTagsJob extends Job<InvalidateCacheTagsPayload> {
+    private readonly cache;
+    constructor(cache: CacheLike);
+    handle(payload: InvalidateCacheTagsPayload): Promise<void>;
+}
+export default InvalidateCacheTagsJob;
+export type { InvalidateCacheTagsPayload };

package/dist/core/openapi/generator.d.ts

@@ -0,0 +1,22 @@
+import type { RegisteredRoute } from "../../bootstrap/routeRegistry";
+interface OpenApiSpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    servers: Array<{
+        url: string;
+        description?: string;
+    }>;
+    paths: Record<string, Record<string, unknown>>;
+    components: {
+        securitySchemes: Record<string, unknown>;
+        schemas?: Record<string, unknown>;
+    };
+}
+declare function generateOpenApiSpec(routes: RegisteredRoute[]): OpenApiSpec;
+declare function renderOpenApiDocument(spec: OpenApiSpec): string;
+declare function renderTypeScriptSdk(spec: OpenApiSpec, apiPrefix?: string): string;
+export type { OpenApiSpec };
+export { generateOpenApiSpec, renderOpenApiDocument, renderTypeScriptSdk };

package/dist/core/openapi/validate.d.ts

@@ -0,0 +1,3 @@
+import type { OpenApiSpec } from "./generator";
+declare function validateOpenApiSpec(spec: OpenApiSpec): string[];
+export { validateOpenApiSpec };

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

@@ -0,0 +1,6 @@
+import type { Queue } from "./index";
+import { createFailedJobService, createQueueWorker, createTrackedJob, type FailedJobService } from "./publicQueue";
+declare const FAILED_JOB_SERVICE_TOKEN = "core.failedJobs";
+declare function registerDefaultJobs(): void;
+declare function createAppQueue(driver: "sync" | "async" | "redis", redisUrl?: string, failedJobs?: FailedJobService): Queue;
+export { createAppQueue, createFailedJobService, createQueueWorker, createTrackedJob, FAILED_JOB_SERVICE_TOKEN, registerDefaultJobs, };

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

@@ -0,0 +1,15 @@
+interface QueueDepthMetrics {
+    high: number;
+    default: number;
+    low: number;
+    total: number;
+}
+interface QueueMetricsSnapshot {
+    driver: string;
+    pending: QueueDepthMetrics;
+    failedCount: number;
+}
+declare function readRedisQueueDepth(redisUrl: string): Promise<QueueDepthMetrics>;
+declare function collectQueueMetrics(): Promise<QueueMetricsSnapshot>;
+export type { QueueDepthMetrics, QueueMetricsSnapshot };
+export { collectQueueMetrics, readRedisQueueDepth };

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

@@ -0,0 +1,8 @@
+declare const OAUTH_STATE_COOKIE = "oauth_state";
+declare function createOAuthStateCookie(): {
+    state: string;
+    cookie: string;
+};
+declare function verifyOAuthState(request: Request, returnedState: string | null): boolean;
+declare function clearOAuthStateCookie(): string;
+export { clearOAuthStateCookie, createOAuthStateCookie, OAUTH_STATE_COOKIE, verifyOAuthState };

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

@@ -0,0 +1,8 @@
+declare const DEFAULT_FETCH_TIMEOUT_MS = 10000;
+interface SafeFetchOptions {
+    timeoutMs?: number;
+    maxRedirects?: number;
+}
+declare function safeFetch(input: string, init?: RequestInit, options?: SafeFetchOptions): Promise<Response>;
+export type { SafeFetchOptions };
+export { DEFAULT_FETCH_TIMEOUT_MS, safeFetch };

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

@@ -0,0 +1,5 @@
+declare function isBlockedHostname(hostname: string): boolean;
+declare function assertSafeOutboundUrl(rawUrl: string, options?: {
+    allowHttp?: boolean;
+}): URL;
+export { assertSafeOutboundUrl, isBlockedHostname };

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

@@ -0,0 +1,3 @@
+declare function parseScimTenantTokens(raw: string | undefined): Map<number, string>;
+declare function resolveScimTenantFromToken(token: string): number | null;
+export { parseScimTenantTokens, resolveScimTenantFromToken };

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

@@ -0,0 +1,2 @@
+declare function verifyStripeWebhookSignature(rawBody: string, signatureHeader: string | null, secret: string, toleranceSeconds?: number): void;
+export { verifyStripeWebhookSignature };

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

@@ -0,0 +1,2 @@
+declare function timingSafeCompareString(left: string, right: string): boolean;
+export { timingSafeCompareString };

package/dist/domain/scim.d.ts

@@ -0,0 +1,9 @@
+export declare const TEST_SCIM_BEARER_TOKEN = "workhub-scim-test-token";
+export declare const DEFAULT_SCIM_BEARER_TOKEN = "workhub-scim-test-token";
+export declare const SCIM_SCHEMAS: {
+    readonly user: "urn:ietf:params:scim:schemas:core:2.0:User";
+    readonly group: "urn:ietf:params:scim:schemas:core:2.0:Group";
+    readonly listResponse: "urn:ietf:params:scim:api:messages:2.0:ListResponse";
+    readonly patchOp: "urn:ietf:params:scim:api:messages:2.0:PatchOp";
+    readonly serviceProviderConfig: "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig";
+};

package/dist/entries/auth/guard.js

@@ -1555,26 +1555,26 @@ class Model {
     throw new Error(`${this.constructor.name}.primaryKey() is not implemented.`);
   }
   static primaryKeyField() {
-    return resolveModelRepository(this).getTable().primaryKey;
+    return resolveModelRepository(Model).getTable().primaryKey;
   }
   static hydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
+    const casts = modelStatics(Model).$casts ?? {};
     return applyCasts(attributes, casts, "hydrate");
   }
   static dehydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
+    const casts = modelStatics(Model).$casts ?? {};
     return applyCasts(attributes, casts, "dehydrate");
   }
   static fromRecord(record, repository, exists = true) {
-    const statics = modelStatics(this);
+    const statics = modelStatics(Model);
     const hydrated = statics.hydrateAttributes(record);
     return new statics(hydrated, repository, exists);
   }
   static boot() {}
   static addGlobalScope(_name, scope) {
-    ensureBooted(this);
-    const existing = modelGlobalScopes.get(this) ?? [];
-    modelGlobalScopes.set(this, [
+    ensureBooted(Model);
+    const existing = modelGlobalScopes.get(Model) ?? [];
+    modelGlobalScopes.set(Model, [
       ...existing,
       scope
     ]);
@@ -1584,17 +1584,17 @@ class Model {
   }
   static query() {
     ensureBooted(this);
-    const repository = resolveModelRepository(this);
+    const repository = resolveModelRepository(Model);
     let query = repository.query();
-    for (const scope of getGlobalScopes(this)) {
+    for (const scope of getGlobalScopes(Model)) {
       query = scope(query);
     }
     return query;
   }
   static async create(attributes) {
     const statics = modelStatics(this);
-    ensureBooted(this);
-    const repository = resolveModelRepository(this);
+    ensureBooted(Model);
+    const repository = resolveModelRepository(Model);
     const table = repository.getTable();
     const timestamps = statics.$timestamps ?? true;
     const assignable = filterMassAssignable(statics.$fillable, statics.$guarded, attributes);
@@ -1604,23 +1604,23 @@ class Model {
     return statics.fromRecord(record, repository, true);
   }
   static async find(id) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
+    const statics = modelStatics(Model);
+    const repository = resolveModelRepository(Model);
     const primaryKey = repository.getTable().primaryKey;
-    const record = await Model.query.call(this).where({ [primaryKey]: id }).first();
+    const record = await Model.query.call(Model).where({ [primaryKey]: id }).first();
     return record ? statics.fromRecord(record, repository, true) : null;
   }
   static async findOrFail(id, errorFactory) {
-    const model = await Model.find.call(this, id);
+    const model = await Model.find.call(Model, id);
     if (model) {
       return model;
     }
-    throw errorFactory?.(id) ?? new NotFoundError(`${this.name} ${String(id)} not found.`);
+    throw errorFactory?.(id) ?? new NotFoundError(`${Model.name} ${String(id)} not found.`);
   }
   static async all(options = {}) {
     const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    let query = Model.query.call(this);
+    const repository = resolveModelRepository(Model);
+    let query = Model.query.call(Model);
     if (options.orderBy) {
       query = query.orderBy(options.orderBy);
     }
@@ -1632,8 +1632,8 @@ class Model {
   }
   static async firstWhere(where, options = {}) {
     const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    let query = Model.query.call(this).where(where);
+    const repository = resolveModelRepository(Model);
+    let query = Model.query.call(Model).where(where);
     if (options.orderBy) {
       query = query.orderBy(options.orderBy);
     }

package/dist/entries/database.js

@@ -1353,26 +1353,26 @@ class Model {
     throw new Error(`${this.constructor.name}.primaryKey() is not implemented.`);
   }
   static primaryKeyField() {
-    return resolveModelRepository(this).getTable().primaryKey;
+    return resolveModelRepository(Model).getTable().primaryKey;
   }
   static hydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
+    const casts = modelStatics(Model).$casts ?? {};
     return applyCasts(attributes, casts, "hydrate");
   }
   static dehydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
+    const casts = modelStatics(Model).$casts ?? {};
     return applyCasts(attributes, casts, "dehydrate");
   }
   static fromRecord(record, repository, exists = true) {
-    const statics = modelStatics(this);
+    const statics = modelStatics(Model);
     const hydrated = statics.hydrateAttributes(record);
     return new statics(hydrated, repository, exists);
   }
   static boot() {}
   static addGlobalScope(_name, scope) {
-    ensureBooted(this);
-    const existing = modelGlobalScopes.get(this) ?? [];
-    modelGlobalScopes.set(this, [
+    ensureBooted(Model);
+    const existing = modelGlobalScopes.get(Model) ?? [];
+    modelGlobalScopes.set(Model, [
       ...existing,
       scope
     ]);
@@ -1382,17 +1382,17 @@ class Model {
   }
   static query() {
     ensureBooted(this);
-    const repository = resolveModelRepository(this);
+    const repository = resolveModelRepository(Model);
     let query = repository.query();
-    for (const scope of getGlobalScopes(this)) {
+    for (const scope of getGlobalScopes(Model)) {
       query = scope(query);
     }
     return query;
   }
   static async create(attributes) {
     const statics = modelStatics(this);
-    ensureBooted(this);
-    const repository = resolveModelRepository(this);
+    ensureBooted(Model);
+    const repository = resolveModelRepository(Model);
     const table = repository.getTable();
     const timestamps = statics.$timestamps ?? true;
     const assignable = filterMassAssignable(statics.$fillable, statics.$guarded, attributes);
@@ -1402,23 +1402,23 @@ class Model {
     return statics.fromRecord(record, repository, true);
   }
   static async find(id) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
+    const statics = modelStatics(Model);
+    const repository = resolveModelRepository(Model);
     const primaryKey = repository.getTable().primaryKey;
-    const record = await Model.query.call(this).where({ [primaryKey]: id }).first();
+    const record = await Model.query.call(Model).where({ [primaryKey]: id }).first();
     return record ? statics.fromRecord(record, repository, true) : null;
   }
   static async findOrFail(id, errorFactory) {
-    const model = await Model.find.call(this, id);
+    const model = await Model.find.call(Model, id);
     if (model) {
       return model;
     }
-    throw errorFactory?.(id) ?? new NotFoundError(`${this.name} ${String(id)} not found.`);
+    throw errorFactory?.(id) ?? new NotFoundError(`${Model.name} ${String(id)} not found.`);
   }
   static async all(options = {}) {
     const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    let query = Model.query.call(this);
+    const repository = resolveModelRepository(Model);
+    let query = Model.query.call(Model);
     if (options.orderBy) {
       query = query.orderBy(options.orderBy);
     }
@@ -1430,8 +1430,8 @@ class Model {
   }
   static async firstWhere(where, options = {}) {
     const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    let query = Model.query.call(this).where(where);
+    const repository = resolveModelRepository(Model);
+    let query = Model.query.call(Model).where(where);
     if (options.orderBy) {
       query = query.orderBy(options.orderBy);
     }