@getstrata/bootstrap 0.2.4 → 0.2.6

package/README.md

@@ -1,6 +1,6 @@
 # @getstrata/bootstrap
 
-Application bootstrap for Strata sibling apps — HttpKernel, service container, and web utilities.
+Application bootstrap for Strata sibling apps: HttpKernel, service container, and web utilities.
 
 ## Install
 
@@ -20,6 +20,8 @@ import {
 } from "@getstrata/bootstrap";
 ```
 
+`CookieSessionStore` reads optional `is_admin` from the user row for global admin routing via `wrapWebGlobalAdmin`.
+
 ## HttpKernel (API / module apps)
 
 ```typescript

package/dist/bootstrap/httpKernel.d.ts

@@ -1,5 +1,4 @@
-import type { Policy } from "../core/auth/policy";
-import { type Middleware, type RouteHandler } from "../core/http/middleware";
+import { type Middleware, type Policy, type RouteHandler } from "@getstrata/core";
 import type { AppDependencies } from "./contracts";
 type MiddlewareGroupName = "api" | "authenticated" | "web";
 declare class HttpKernel {

package/dist/bootstrap/middleware.d.ts

@@ -1,4 +1,4 @@
-import { type Middleware } from "../core/http/middleware";
+import { type Middleware } from "@getstrata/core";
 import type { AppDependencies } from "./contracts";
 declare function createDefaultMiddleware(dependencies: AppDependencies): Middleware[];
 export { createDefaultMiddleware };

package/dist/bootstrap/web/session.d.ts

@@ -3,6 +3,7 @@ export interface SessionUser {
     name: string;
     email: string;
     learn_subscriber?: boolean;
+    is_admin?: boolean;
 }
 type SqlClient = {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;

package/dist/core/admin/formatValue.d.ts

@@ -0,0 +1,3 @@
+import type { AdminColumnType } from "./types.ts";
+declare function formatAdminValue(value: unknown, type?: AdminColumnType): string;
+export { formatAdminValue };

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

@@ -0,0 +1,3 @@
+export { formatAdminValue } from "./formatValue.ts";
+export { AdminResourceRegistry } from "./registry.ts";
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, } from "./types.ts";

package/dist/core/admin/registry.d.ts

@@ -0,0 +1,11 @@
+import type { AdminResource, AdminResourceDefinition } from "./types.ts";
+declare class AdminResourceRegistry {
+    private readonly resources;
+    constructor();
+    register<TEntity extends object>(resource: AdminResource<TEntity>): void;
+    get(name: string): AdminResource<object> | undefined;
+    list(): AdminResourceDefinition[];
+    all(): AdminResource<object>[];
+    clear(): void;
+}
+export { AdminResourceRegistry };

package/dist/core/admin/types.d.ts

@@ -0,0 +1,24 @@
+import type { PaginatedResult } from "../pagination/index.ts";
+type AdminColumnType = "text" | "number" | "boolean" | "datetime" | "code";
+interface AdminColumn {
+    key: string;
+    label: string;
+    type?: AdminColumnType;
+}
+interface AdminResourceHandlers<TEntity extends object> {
+    paginate(options: {
+        page: number;
+        perPage: number;
+    }): Promise<PaginatedResult<TEntity>>;
+    findById?(id: number): Promise<TEntity | null>;
+}
+interface AdminResourceDefinition {
+    name: string;
+    label: string;
+    labelPlural: string;
+    columns: AdminColumn[];
+}
+interface AdminResource<TEntity extends object> extends AdminResourceDefinition {
+    handlers: AdminResourceHandlers<TEntity>;
+}
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, };

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

@@ -1,5 +1,5 @@
 import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
-import { type BelongsToRelation, type HasManyRelation } from "./relationships.ts";
+import { type BelongsToRelation, type HasManyRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } from "./relationships.ts";
 import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
@@ -54,6 +54,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
     loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
     loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
+    loadMorphManyForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphManyRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
+    loadMorphOneForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphOneRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity | undefined>>;
+    loadMorphToForChildren<TChild extends object, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, OwnerKey>>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[MorphIdKey], TParent>>;
 }
 export default BaseRepository;
 export type { DatabaseConnection };

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

@@ -5,8 +5,8 @@ export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
 export type { CastType, GlobalScopeFn, ModelConstructor } from "./model.ts";
 export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "./model.ts";
 export { buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, } from "./query.ts";
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "./relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "./relationships.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "./relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "./relationships.ts";
 export { RepositoryQuery } from "./repositoryQuery.ts";
 export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "./schema/index.ts";
 export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "./schema/index.ts";

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

@@ -52,5 +52,49 @@ declare function indexHasManyRelation<TParent, TChild, LocalKey extends keyof TP
 declare function indexHasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasOneRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild | undefined>;
 declare function indexBelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parents: readonly TParent[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>): Map<TChild[ForeignKey], TParent>;
 declare function indexBelongsToManyRelation<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string>(parents: readonly TParent[], pivotRows: readonly Pivot[], relatedRows: readonly TRelated[], relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>): Map<TParent[ParentKey], TRelated[]>;
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation };
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, };
+interface MorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
+    type: "morphMany";
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}
+interface MorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
+    type: "morphOne";
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}
+interface MorphToRelation<TChild, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
+    type: "morphTo";
+    name: string;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+}
+declare function morphMany<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}): MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>;
+declare function morphOne<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}): MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>;
+declare function morphTo<TChild, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+}): MorphToRelation<TChild, MorphTypeKey, MorphIdKey>;
+declare function indexMorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild[]>;
+declare function indexMorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild | undefined>;
+declare function indexMorphToRelation<TChild, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parentsByType: ReadonlyMap<string, ReadonlyMap<TParent[OwnerKey], TParent>>, relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>): Map<TChild[MorphIdKey], TParent>;
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, };
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, };

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

@@ -1,6 +1,6 @@
 import type { PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
-import type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
+import type { BelongsToRelation, HasManyRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
 import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
@@ -22,6 +22,9 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     having(having: QueryWhere<TEntity>): this;
     withHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
     withBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): this;
+    withMorphMany<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphManyRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
+    withMorphOne<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphOneRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
+    withMorphTo<TParent extends object, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string, Alias extends string>(as: Alias, relation: MorphToRelation<TEntity, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, keyof TParent & string>>, options?: Omit<QueryOptions<TParent>, "where">): this;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
     paginate(options: {

package/dist/core/mail/mailer.d.ts

@@ -2,6 +2,7 @@ interface MailMessage {
     to: string;
     subject: string;
     body: string;
+    html?: string;
 }
 interface MailDriver {
     send(message: MailMessage): Promise<void>;
@@ -16,6 +17,7 @@ interface SmtpConfig {
 }
 type SmtpTransport = (config: SmtpConfig, message: MailMessage) => Promise<void>;
 declare function resolveSmtpConfig(): SmtpConfig;
+declare function buildSmtpPayload(from: string, message: MailMessage): string;
 declare class LogMailDriver implements MailDriver {
     send(message: MailMessage): Promise<void>;
 }
@@ -33,4 +35,4 @@ declare class Mailer {
 declare function createMailDriver(): MailDriver;
 declare function mailer(): Mailer;
 export type { MailDriver, MailMessage, SmtpConfig, SmtpTransport };
-export { createMailDriver, LogMailDriver, Mailer, mailer, resolveSmtpConfig, SmtpMailDriver };
+export { buildSmtpPayload, createMailDriver, LogMailDriver, Mailer, mailer, resolveSmtpConfig, SmtpMailDriver, };

package/dist/core/mail/markdownMail.d.ts

@@ -0,0 +1,15 @@
+interface MarkdownMailLayoutOptions {
+    title?: string;
+    preview?: string;
+    footer?: string;
+}
+interface RenderedMarkdownMail {
+    html: string;
+    text: string;
+}
+declare function stripMarkdown(markdown: string): string;
+declare function markdownToHtml(markdown: string): string;
+declare function wrapMarkdownMailLayout(bodyHtml: string, options?: MarkdownMailLayoutOptions): string;
+declare function renderMarkdownMail(markdown: string, options?: MarkdownMailLayoutOptions): RenderedMarkdownMail;
+export type { MarkdownMailLayoutOptions, RenderedMarkdownMail };
+export { markdownToHtml, renderMarkdownMail, stripMarkdown, wrapMarkdownMailLayout };

package/dist/core/mail/markdownMailable.d.ts

@@ -0,0 +1,12 @@
+import type { Mailer, MailMessage } from "./mailer.ts";
+import { type MarkdownMailLayoutOptions } from "./markdownMail.ts";
+interface MarkdownMailableInput {
+    to: string;
+    subject: string;
+    markdown: string;
+    layout?: MarkdownMailLayoutOptions;
+}
+declare function buildMarkdownMailMessage(input: MarkdownMailableInput): MailMessage;
+declare function sendMarkdownMail(mailer: Mailer, input: MarkdownMailableInput): Promise<void>;
+export type { MarkdownMailableInput };
+export { buildMarkdownMailMessage, sendMarkdownMail };

package/dist/core/notifications/dispatcher.d.ts

@@ -0,0 +1,13 @@
+import type { Mailer } from "../mail/mailer.ts";
+import type { Notification } from "./notification.ts";
+import type { DatabaseNotificationStore, Notifiable } from "./types.ts";
+declare class NotificationDispatcher {
+    private readonly mailer;
+    private readonly databaseStore;
+    constructor(mailer: Mailer, databaseStore?: DatabaseNotificationStore | null);
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+    private sendMail;
+    private sendDatabase;
+}
+declare function createNotificationDispatcher(mailer: Mailer, databaseStore?: DatabaseNotificationStore): NotificationDispatcher;
+export { createNotificationDispatcher, NotificationDispatcher };

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

@@ -0,0 +1,3 @@
+export { createNotificationDispatcher, NotificationDispatcher } from "./dispatcher.ts";
+export { Notification } from "./notification.ts";
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, } from "./types.ts";

package/dist/core/notifications/notification.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseNotificationPayload, MailNotificationMessage, NotificationChannelName } from "./types.ts";
+declare abstract class Notification<TNotifiable = unknown> {
+    via(_notifiable: TNotifiable): NotificationChannelName[];
+    toMail(_notifiable: TNotifiable): MailNotificationMessage | null;
+    toDatabase(_notifiable: TNotifiable): DatabaseNotificationPayload | null;
+}
+export { Notification };

package/dist/core/notifications/types.d.ts

@@ -0,0 +1,25 @@
+type NotificationChannelName = "mail" | "database";
+interface MailNotificationMessage {
+    subject: string;
+    markdown?: string;
+    body?: string;
+    html?: string;
+}
+interface DatabaseNotificationPayload {
+    type: string;
+    title: string;
+    body: string;
+    data?: Record<string, unknown>;
+    notifiableType?: string | null;
+    notifiableId?: number | null;
+}
+interface DatabaseNotificationStore {
+    create(input: DatabaseNotificationPayload & {
+        userId: number;
+    }): Promise<Record<string, unknown>>;
+}
+interface Notifiable {
+    getNotificationKey(): string | number;
+    routeNotificationFor(channel: NotificationChannelName): string | number | null;
+}
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, };

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

@@ -10,6 +10,7 @@ declare class FailedJobService {
     }): Promise<FailedJobRecord>;
     listRecent(limit?: number): Promise<FailedJobRecord[]>;
     retry(id: number): Promise<FailedJobRecord>;
+    delete(id: number): Promise<void>;
     flush(): Promise<number>;
 }
 export default FailedJobService;

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

@@ -2,6 +2,7 @@ import FailedJobRepository from "./failedJobRepository.ts";
 import FailedJobService from "./failedJobService.ts";
 import type { Job, Queue } from "./index.ts";
 import { jobRegistry } from "./jobRegistry.ts";
+import { runQueueJob } from "./jobRunner.ts";
 import { QueueWorker, RedisQueue } from "./redisQueue.ts";
 import { ResilientQueue } from "./resilientQueue.ts";
 declare function createFailedJobService(): FailedJobService;
@@ -12,4 +13,4 @@ declare function createProductionQueue(driver: "sync" | "async" | "redis", optio
     registerJobs?: () => void;
 }): Queue;
 declare function createQueueWorker(redisUrl: string, failedJobs?: FailedJobService): QueueWorker;
-export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, };
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, runQueueJob, };

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

@@ -12,8 +12,9 @@ interface S3StorageConfig {
     endpoint?: string;
 }
 declare class LocalStorageDriver implements StorageDriver {
-    private readonly rootDirectory;
-    constructor(rootDirectory: string);
+    private readonly rootDirectory?;
+    constructor(rootDirectory?: string | undefined);
+    private resolveRootDirectory;
     private resolvePath;
     put(path: string, contents: string | Uint8Array): Promise<string>;
     get(path: string): Promise<Uint8Array | null>;
@@ -37,5 +38,7 @@ declare function resolveS3Config(): S3StorageConfig;
 declare function createS3Client(config?: S3StorageConfig): S3Client;
 declare function createStorageDriver(): StorageDriver;
 declare function storage(): StorageManager;
+/** Test hook: drop the process-wide storage singleton (e.g. after changing STORAGE_PATH). */
+declare function resetDefaultStorage(): void;
 export type { S3StorageConfig, StorageDriver };
-export { createS3Client, createStorageDriver, LocalStorageDriver, resolveS3Config, S3StorageDriver, StorageManager, storage, };
+export { createS3Client, createStorageDriver, LocalStorageDriver, resetDefaultStorage, resolveS3Config, S3StorageDriver, StorageManager, storage, };

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

@@ -5,9 +5,12 @@
 export { resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, } from "../bootstrap/applicationRegistry.ts";
 export type { ServiceProvider } from "../bootstrap/contracts.ts";
 export { ConfigStore, resolveService, ServiceContainer, } from "../bootstrap/contracts.ts";
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, } from "../core/admin/index.ts";
+export { AdminResourceRegistry, formatAdminValue, } from "../core/admin/index.ts";
 export type { AbilityChecker } from "../core/auth/abilityChecker.ts";
 export type { AuthUser } from "../core/auth/authContext.ts";
 export { currentAuthUser, runWithAuthUser } from "../core/auth/authContext.ts";
+export { createMembershipMiddleware } from "../core/auth/membershipMiddleware.ts";
 export { Policy, PolicyGate } from "../core/auth/policy.ts";
 export { default as CacheRepository } from "../core/cache/repository.ts";
 export { CACHE_TAGS } from "../core/cache/tags.ts";
@@ -21,8 +24,8 @@ export { freshDatabase, getMigrationStatus, loadMigrationsFromDirectory, migrate
 export type { Migration, MigrationDatabase, MigrationStatus, } from "../core/database/migrations/types.ts";
 export type { CastType, GlobalScopeFn, ModelConstructor } from "../core/database/model.ts";
 export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "../core/database/model.ts";
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "../core/database/relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "../core/database/relationships.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "../core/database/relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "../core/database/relationships.ts";
 export { RepositoryQuery } from "../core/database/repositoryQuery.ts";
 export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "../core/database/schema/index.ts";
 export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "../core/database/schema/index.ts";
@@ -38,16 +41,20 @@ export { EventBus } from "../core/events/eventBus.ts";
 export { auth, cache, config, events, log, mail, policyGate, queue, storage, } from "../core/facades/index.ts";
 export { createBodySizeLimitMiddleware } from "../core/http/bodySizeLimitMiddleware.ts";
 export { readBunRequestCookie, readRequestCookie } from "../core/http/cookies.ts";
+export { createCorsMiddleware } from "../core/http/corsMiddleware.ts";
 export { createCsrfMiddleware } from "../core/http/csrfMiddleware.ts";
 export { createCsrfProtection } from "../core/http/csrfProtection.ts";
 export { createCsrfTokenCookie, readSubmittedCsrfToken, readSubmittedCsrfTokenFromBody, resolveCsrfToken, resolveCsrfTokenForRequest, verifyCsrfToken, } from "../core/http/csrfToken.ts";
 export { assertIfMatch, etagFromResource, isEtagEnabled, } from "../core/http/etag.ts";
+export { createFlashMiddleware } from "../core/http/flashMiddleware.ts";
 export { FormRequest } from "../core/http/formRequest.ts";
-export { applyMiddlewareToRoutes, composeMiddleware, createAuthMiddleware, createAuthorizeMiddleware, createdResponse, createRequireAuthMiddleware, jsonResponse, noContentResponse, paginatedResponse, parsePaginationQuery, securedBindRouteModel, securedBindRouteModelByKey, withErrorHandling, withMiddleware, } from "../core/http/index.ts";
+export { applyMiddlewareToRoutes, composeMiddleware, createAuthMiddleware, createAuthorizeMiddleware, createdResponse, createRequireAuthMiddleware, jsonResponse, noContentResponse, paginatedResponse, parsePaginationQuery, requestIdMiddleware, securedBindRouteModel, securedBindRouteModelByKey, withErrorHandling, withMiddleware, } from "../core/http/index.ts";
 export { createLoginThrottleMiddleware } from "../core/http/loginThrottleMiddleware.ts";
 export { createMemoryThrottleMiddleware } from "../core/http/memoryThrottleMiddleware.ts";
 export { createMetricsMiddleware, normalizeMetricPath } from "../core/http/metricsMiddleware.ts";
 export type { Middleware, RouteHandler } from "../core/http/middleware.ts";
+export { createRequireAbilityMiddleware } from "../core/http/requireAbilityMiddleware.ts";
+export { createRequireGlobalAdminMiddleware } from "../core/http/requireGlobalAdminMiddleware.ts";
 export { createRequireWebAuthMiddleware } from "../core/http/requireWebAuthMiddleware.ts";
 export { serializeDate, toPaginatedResourceCollection, toResourceCollection, } from "../core/http/resources.ts";
 export type { RouteRequest } from "../core/http/route.ts";
@@ -55,18 +62,28 @@ export { createSecurityHeadersMiddleware } from "../core/http/securityHeadersMid
 export { createThrottleMiddleware } from "../core/http/throttleMiddleware.ts";
 export { WebFormRequest } from "../core/http/webFormRequest.ts";
 export { installGracefulShutdownSignals, registerShutdownHandler, runGracefulShutdown, } from "../core/lifecycle/gracefulShutdown.ts";
+export { createRequestLoggingMiddleware } from "../core/logging/requestLoggingMiddleware.ts";
 export type { MailDriver, MailMessage } from "../core/mail/mailer.ts";
-export { LogMailDriver, Mailer, mailer } from "../core/mail/mailer.ts";
+export { buildSmtpPayload, LogMailDriver, Mailer, mailer, } from "../core/mail/mailer.ts";
+export type { MarkdownMailLayoutOptions, RenderedMarkdownMail } from "../core/mail/markdownMail.ts";
+export { markdownToHtml, renderMarkdownMail, stripMarkdown, wrapMarkdownMailLayout, } from "../core/mail/markdownMail.ts";
+export type { MarkdownMailableInput } from "../core/mail/markdownMailable.ts";
+export { buildMarkdownMailMessage, sendMarkdownMail } from "../core/mail/markdownMailable.ts";
 export type { MetricLabels } from "../core/metrics/prometheus.ts";
 export { PrometheusRegistry, prometheusRegistry } from "../core/metrics/prometheus.ts";
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, } from "../core/notifications/index.ts";
+export { createNotificationDispatcher, Notification, NotificationDispatcher, } from "../core/notifications/index.ts";
 export type { CursorPaginatedResult, PaginatedResult, PaginationMeta, } from "../core/pagination/index.ts";
 export type { Queue, QueuePriority } from "../core/queue/index.ts";
 export { AsyncQueue, createQueue, Job, SyncQueue } from "../core/queue/index.ts";
-export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, } from "../core/queue/publicQueue.ts";
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, runQueueJob, } from "../core/queue/publicQueue.ts";
 export type { ScheduledTask } from "../core/scheduler/schedule.ts";
 export { appSchedule, runDueScheduledTasks, Schedule } from "../core/scheduler/schedule.ts";
+export { isPublicReadsEnabled } from "../core/security/publicReads.ts";
 export type { StorageDriver } from "../core/storage/storage.ts";
-export { LocalStorageDriver, StorageManager } from "../core/storage/storage.ts";
+export { LocalStorageDriver, resetDefaultStorage, StorageManager, } from "../core/storage/storage.ts";
+export { createTenantMiddleware } from "../core/tenant/tenantMiddleware.ts";
+export { createTracingMiddleware } from "../core/tracing/tracingMiddleware.ts";
 export type { ValidationRule, ValidationSchema } from "../core/validation/rules.ts";
 export { emailRule, maxLength, minLength, required, stringRule, validateObject, } from "../core/validation/rules.ts";
 export { DEFAULT_VIEWS_DIRECTORY, EtaViewEngine, htmlResponse, isHtmxRequest, resolveWebLayoutData, } from "../core/view/index.ts";