@getstrata/core 0.3.0 → 0.3.8

package/dist/bootstrap/config.d.ts

@@ -9,6 +9,7 @@ declare const CORE_CACHE_TOKEN = "core.cache";
 declare const CORE_QUEUE_TOKEN = "core.queue";
 declare const CORE_POLICY_GATE_TOKEN = "core.policyGate";
 declare const CORE_AUTH_TOKEN = "core.auth";
+declare const CORE_TOKEN_SERVICE_TOKEN = "core.tokenService";
 declare const AUTH_DEV_HEADERS_CONFIG_KEY = "auth.allowDevHeaders";
 declare const DEFAULT_APP_PORT = 3000;
 declare const DEFAULT_CACHE_TTL_MS = 3600000;
@@ -16,4 +17,4 @@ declare const DEFAULT_CACHE_MAX_ENTRIES = 100;
 declare const DEFAULT_CACHE_DRIVER = "array";
 declare const DEFAULT_API_TOKEN = "";
 declare const DEFAULT_QUEUE_DRIVER = "sync";
-export { APP_PORT_CONFIG_KEY, AUTH_DEV_HEADERS_CONFIG_KEY, CACHE_DRIVER_CONFIG_KEY, CACHE_MAX_ENTRIES_CONFIG_KEY, CACHE_TTL_MS_CONFIG_KEY, CORE_AUTH_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, DATABASE_URL_CONFIG_KEY, DEFAULT_API_TOKEN, DEFAULT_APP_PORT, DEFAULT_CACHE_DRIVER, DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_TTL_MS, DEFAULT_QUEUE_DRIVER, REDIS_URL_CONFIG_KEY, };
+export { APP_PORT_CONFIG_KEY, AUTH_DEV_HEADERS_CONFIG_KEY, CACHE_DRIVER_CONFIG_KEY, CACHE_MAX_ENTRIES_CONFIG_KEY, CACHE_TTL_MS_CONFIG_KEY, CORE_AUTH_TOKEN, CORE_CACHE_TOKEN, CORE_CONFIG_TOKEN, CORE_POLICY_GATE_TOKEN, CORE_QUEUE_TOKEN, CORE_TOKEN_SERVICE_TOKEN, DATABASE_URL_CONFIG_KEY, DEFAULT_API_TOKEN, DEFAULT_APP_PORT, DEFAULT_CACHE_DRIVER, DEFAULT_CACHE_MAX_ENTRIES, DEFAULT_CACHE_TTL_MS, DEFAULT_QUEUE_DRIVER, REDIS_URL_CONFIG_KEY, };

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

@@ -0,0 +1,6 @@
+import type { AuthUser } from "./authContext";
+interface AbilityChecker {
+    tokenCan(user: AuthUser | null, ability: string): boolean;
+    requireAbility(user: AuthUser | null, ability: string): void;
+}
+export type { AbilityChecker };

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

@@ -1,5 +1,6 @@
 import { type PaginatedResult } from "../pagination/index.ts";
 import { type BelongsToRelation, type HasManyRelation } from "./relationships.ts";
+import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
 interface DatabaseConnection {
@@ -27,6 +28,8 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     forceDeleteById(id: TEntity[PrimaryKey]): Promise<boolean>;
     restoreById(id: TEntity[PrimaryKey]): Promise<TEntity | null>;
     withConnection(connection: DatabaseConnection): this;
+    getConnection(): DatabaseConnection;
+    query(where?: QueryWhere<TEntity>): RepositoryQuery<TEntity, PrimaryKey>;
     protected findWhere(where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
     protected countWhere(where?: QueryWhere<TEntity>, options?: Pick<QueryOptions<TEntity>, "withTrashed" | "onlyTrashed">): Promise<number>;
     protected averageColumn(column: keyof TEntity & string, where?: QueryWhere<TEntity>): Promise<number>;
@@ -36,9 +39,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
         value: TEntity[K] | null;
         count: number;
     }>>;
-    protected 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[]>;
-    protected 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[]>>;
-    protected 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>>;
+    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>>;
 }
 export default BaseRepository;
 export type { DatabaseConnection };

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

@@ -5,6 +5,7 @@ export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
 export { buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, qualifyColumn, quoteIdentifier, resolveSoftDeleteColumn, } from "./query.ts";
 export type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
 export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "./relationships.ts";
+export { RepositoryQuery } from "./repositoryQuery.ts";
 export type { TableDefinition } from "./table.ts";
 export { defineTable } from "./table.ts";
 export { runInTransaction } from "./transaction.ts";

package/dist/core/database/migrations/runner.d.ts

@@ -0,0 +1,19 @@
+import type { Migration, MigrationDatabase, MigrationStatus } from "./types";
+type AppliedMigrationRow = {
+    name: string;
+    batch: number | string;
+};
+declare function ensureMigrationsTable(db: MigrationDatabase): Promise<void>;
+declare function getAppliedMigrations(db: MigrationDatabase): Promise<AppliedMigrationRow[]>;
+declare function loadMigrationsFromDirectory(directory: string): Promise<Migration[]>;
+declare function getMigrationStatus(db: MigrationDatabase, migrations: Migration[]): Promise<MigrationStatus[]>;
+declare function migrateDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    onMigration?: (name: string) => void;
+}): Promise<number>;
+declare function rollbackDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    onMigration?: (name: string) => void;
+}): Promise<number>;
+declare function freshDatabase(db: MigrationDatabase, migrations: Migration[], options?: {
+    onMigration?: (name: string) => void;
+}): Promise<void>;
+export { ensureMigrationsTable, freshDatabase, getAppliedMigrations, getMigrationStatus, loadMigrationsFromDirectory, migrateDatabase, rollbackDatabase, };

package/dist/core/database/migrations/types.d.ts

@@ -0,0 +1,14 @@
+interface MigrationDatabase {
+    unsafe<T = unknown>(query: string, params?: readonly unknown[]): Promise<T[]>;
+}
+interface Migration {
+    name: string;
+    up(db: MigrationDatabase): Promise<void>;
+    down(db: MigrationDatabase): Promise<void>;
+}
+type MigrationStatus = {
+    name: string;
+    status: "up" | "pending";
+    batch: number | null;
+};
+export type { Migration, MigrationDatabase, MigrationStatus };

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

@@ -0,0 +1,28 @@
+import type BaseRepository from "./baseRepository";
+import type { BelongsToRelation, HasManyRelation } from "./relationships";
+import type { RepositoryQuery } from "./repositoryQuery";
+import type { QueryOptions, QueryWhere } from "./types";
+interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>> {
+    new (attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>): TModel;
+}
+declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
+    protected readonly attributes: TEntity;
+    protected readonly repository: BaseRepository<TEntity, PrimaryKey>;
+    constructor(attributes: TEntity, repository: BaseRepository<TEntity, PrimaryKey>);
+    get<K extends keyof TEntity>(key: K): TEntity[K];
+    get id(): TEntity[PrimaryKey];
+    toObject(): TEntity;
+    protected primaryKey(): PrimaryKey;
+    static repository<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>): BaseRepository<TEntity, PrimaryKey>;
+    static query<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>): RepositoryQuery<TEntity, PrimaryKey>;
+    static find<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, id: TEntity[PrimaryKey]): Promise<TModel | null>;
+    static findOrFail<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, id: TEntity[PrimaryKey], errorFactory?: (id: TEntity[PrimaryKey]) => Error): Promise<TModel>;
+    static all<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, options?: QueryOptions<TEntity>): Promise<TModel[]>;
+    static firstWhere<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(this: ModelConstructor<TEntity, PrimaryKey, TModel>, where: QueryWhere<TEntity>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<TModel | null>;
+    loadHasMany<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">): Promise<this & Record<Alias, TChild[]>>;
+    loadBelongsTo<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">): Promise<this & Record<Alias, TParent | undefined>>;
+    mergeAttributes(patch: Partial<TEntity>): this;
+}
+declare function registerModelRepository<TEntity extends object, PrimaryKey extends keyof TEntity & string, TModel extends Model<TEntity, PrimaryKey>>(model: ModelConstructor<TEntity, PrimaryKey, TModel>, repository: BaseRepository<TEntity, PrimaryKey>): ModelConstructor<TEntity, PrimaryKey, TModel> & typeof Model;
+export type { ModelConstructor };
+export { Model, registerModelRepository };

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

@@ -0,0 +1,20 @@
+import type BaseRepository from "./baseRepository.ts";
+import type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
+import type { QueryOptions, QueryWhere } from "./types.ts";
+type LoadedRow = Record<string, unknown>;
+declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof TEntity & string> {
+    private readonly repository;
+    private whereClause;
+    private queryOptions;
+    private readonly eagerLoads;
+    constructor(repository: BaseRepository<TEntity, PrimaryKey>, whereClause?: QueryWhere<TEntity>, queryOptions?: Omit<QueryOptions<TEntity>, "where">);
+    where(where: QueryWhere<TEntity>): this;
+    orderBy(orderBy: QueryOptions<TEntity>["orderBy"]): this;
+    limit(limit: number): 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;
+    get(): Promise<Array<TEntity & LoadedRow>>;
+    first(): Promise<(TEntity & LoadedRow) | null>;
+    private attach;
+}
+export { RepositoryQuery };

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

@@ -1,4 +1,4 @@
-import type TokenService from "../../modules/user/tokenService";
+import type { AbilityChecker } from "../auth/abilityChecker";
 import type { Middleware } from "./middleware";
-declare function createRequireAbilityMiddleware(tokenService: TokenService): (ability: string) => Middleware;
+declare function createRequireAbilityMiddleware(abilityChecker: AbilityChecker): (ability: string) => Middleware;
 export { createRequireAbilityMiddleware };

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

@@ -1,6 +1,7 @@
 declare abstract class WebFormRequest<TOutput> {
     authorize(_request: Request): boolean | Promise<boolean>;
     protected abstract parse(payload: unknown): TOutput;
+    validatePayload(payload: unknown): TOutput;
     validate(request: Request): Promise<TOutput>;
 }
 export { WebFormRequest };

package/dist/core/validation/rules.d.ts

@@ -0,0 +1,17 @@
+type ValidationRule = (field: string, value: unknown, payload: Record<string, unknown>) => string | undefined;
+type ValidationSchema = Record<string, ValidationRule[]>;
+declare function required(): ValidationRule;
+declare function stringRule(): ValidationRule;
+declare function minLength(minimum: number): ValidationRule;
+declare function maxLength(maximum: number): ValidationRule;
+declare function pattern(expression: RegExp): ValidationRule;
+declare function enumRule<TValue extends string>(allowedValues: readonly TValue[]): ValidationRule;
+declare function optional(): ValidationRule;
+declare function integerRule(): ValidationRule;
+declare function emailRule(): ValidationRule;
+declare function confirmed(fieldName: string): ValidationRule;
+declare function positiveIntegerRule(): ValidationRule;
+declare function integerRange(minimum: number, maximum: number): ValidationRule;
+declare function validateObject(payload: unknown, schema: ValidationSchema): Record<string, unknown>;
+export type { ValidationRule, ValidationSchema };
+export { confirmed, emailRule, enumRule, integerRange, integerRule, maxLength, minLength, optional, pattern, positiveIntegerRule, required, stringRule, validateObject, };

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

@@ -4,13 +4,22 @@
  */
 export type { ServiceProvider } from "../bootstrap/contracts";
 export { ConfigStore, resolveService, ServiceContainer, } from "../bootstrap/contracts";
+export type { AbilityChecker } from "../core/auth/abilityChecker";
 export type { AuthUser } from "../core/auth/authContext";
 export { currentAuthUser, runWithAuthUser } from "../core/auth/authContext";
-export { Policy } from "../core/auth/policy";
+export { Policy, PolicyGate } from "../core/auth/policy";
 export { default as CacheRepository } from "../core/cache/repository";
 export { CACHE_TAGS } from "../core/cache/tags";
+export type { DatabaseConnection } from "../core/database/baseRepository";
 export { default as BaseRepository } from "../core/database/baseRepository";
+export { freshDatabase, getMigrationStatus, loadMigrationsFromDirectory, migrateDatabase, rollbackDatabase, } from "../core/database/migrations/runner";
+export type { Migration, MigrationDatabase, MigrationStatus, } from "../core/database/migrations/types";
+export { Model, registerModelRepository } from "../core/database/model";
+export type { BelongsToRelation, HasManyRelation } from "../core/database/relationships";
+export { belongsTo, hasMany, indexBelongsToRelation, indexHasManyRelation, } from "../core/database/relationships";
+export { RepositoryQuery } from "../core/database/repositoryQuery";
 export { defineTable } from "../core/database/table";
+export type { QueryOptions, QueryOrder, QueryWhere, } from "../core/database/types";
 export { BadRequestError, ConflictError, ForbiddenError, NotFoundError, PreconditionFailedError, UnauthorizedError, UnprocessableEntityError, ValidationError, } from "../core/errors/http";
 export { EventBus } from "../core/events/eventBus";
 export { auth, cache, config, events, log, mail, policyGate, queue, storage, } from "../core/facades";
@@ -28,3 +37,5 @@ 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";
+export type { ValidationRule, ValidationSchema } from "../core/validation/rules";
+export { emailRule, maxLength, minLength, required, stringRule, validateObject, } from "../core/validation/rules";

package/dist/index.js

@@ -699,6 +699,18 @@ function buildDeleteByIdQuery(table, id) {
 }
 
 // ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
+}
+function belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
   for (const parent of parents) {
@@ -730,6 +742,86 @@ function indexBelongsToRelation(children, parents, relation) {
   return result;
 }
 
+// ../../src/core/database/repositoryQuery.ts
+class RepositoryQuery {
+  repository;
+  whereClause;
+  queryOptions;
+  eagerLoads = [];
+  constructor(repository, whereClause = {}, queryOptions = {}) {
+    this.repository = repository;
+    this.whereClause = whereClause;
+    this.queryOptions = queryOptions;
+  }
+  where(where) {
+    this.whereClause = { ...this.whereClause, ...where };
+    return this;
+  }
+  orderBy(orderBy) {
+    this.queryOptions = { ...this.queryOptions, orderBy };
+    return this;
+  }
+  limit(limit) {
+    this.queryOptions = { ...this.queryOptions, limit };
+    return this;
+  }
+  withHasMany(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasMany",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withBelongsTo(as, relation, parentRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "belongsTo",
+      as,
+      relation,
+      repository: parentRepository,
+      options
+    });
+    return this;
+  }
+  async get() {
+    const rows = await this.repository.findAll({
+      ...this.queryOptions,
+      where: this.whereClause
+    });
+    return await this.attach(rows);
+  }
+  async first() {
+    const rows = await this.get();
+    return rows[0] ?? null;
+  }
+  async attach(rows) {
+    if (rows.length === 0 || this.eagerLoads.length === 0) {
+      return rows.map((row) => ({ ...row }));
+    }
+    let result = rows.map((row) => ({ ...row }));
+    for (const load of this.eagerLoads) {
+      if (load.kind === "hasMany") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+        }));
+        continue;
+      }
+      const relation = load.relation;
+      const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
+      result = result.map((row) => ({
+        ...row,
+        [load.as]: grouped.get(row[relation.foreignKey])
+      }));
+    }
+    return result;
+  }
+}
+
 // ../../src/core/database/baseRepository.ts
 class BaseRepository {
   table;
@@ -866,6 +958,12 @@ class BaseRepository {
     clone.connection = connection;
     return clone;
   }
+  getConnection() {
+    return this.connection;
+  }
+  query(where = {}) {
+    return new RepositoryQuery(this, where);
+  }
   async findWhere(where, options = {}) {
     return await this.findAll({ ...options, where });
   }
@@ -926,6 +1024,166 @@ class BaseRepository {
   }
 }
 var baseRepository_default = BaseRepository;
+// ../../src/core/database/migrations/runner.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+import { pathToFileURL } from "url";
+var MIGRATIONS_TABLE = "framework_migrations";
+async function ensureMigrationsTable(db2) {
+  await db2.unsafe(`
+    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+      name TEXT PRIMARY KEY,
+      batch INTEGER NOT NULL,
+      run_on TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    )
+  `);
+}
+async function getAppliedMigrations(db2) {
+  await ensureMigrationsTable(db2);
+  return await db2.unsafe(`
+    SELECT name, batch
+    FROM ${MIGRATIONS_TABLE}
+    ORDER BY batch ASC, name ASC
+  `);
+}
+async function loadMigrationsFromDirectory(directory) {
+  const entries = await readdir(directory);
+  const migrationFiles = entries.filter((entry) => entry.endsWith(".ts") && entry !== "types.ts" && entry !== "index.ts" && entry !== "runner.ts").sort();
+  const loadedMigrations = await Promise.all(migrationFiles.map(async (fileName) => {
+    const moduleUrl = pathToFileURL(join(directory, fileName)).href;
+    const module = await import(moduleUrl);
+    return module.default;
+  }));
+  return loadedMigrations.filter((migration) => migration?.name !== undefined);
+}
+async function getMigrationStatus(db2, migrations) {
+  const applied = await getAppliedMigrations(db2);
+  const appliedByName = new Map(applied.map(({ name, batch }) => [name, Number(batch)]));
+  return migrations.map(({ name }) => ({
+    name,
+    status: appliedByName.has(name) ? "up" : "pending",
+    batch: appliedByName.get(name) ?? null
+  }));
+}
+async function migrateDatabase(db2, migrations, options = {}) {
+  const applied = await getAppliedMigrations(db2);
+  const appliedNames = new Set(applied.map(({ name }) => name));
+  const nextBatch = applied.reduce((currentMax, { batch }) => Math.max(currentMax, Number(batch)), 0) + 1;
+  const pendingMigrations = migrations.filter(({ name }) => !appliedNames.has(name));
+  for (const migration of pendingMigrations) {
+    options.onMigration?.(migration.name);
+    await migration.up(db2);
+    await db2.unsafe(`INSERT INTO ${MIGRATIONS_TABLE} (name, batch) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING`, [migration.name, nextBatch]);
+  }
+  return pendingMigrations.length;
+}
+async function rollbackDatabase(db2, migrations, options = {}) {
+  const applied = await getAppliedMigrations(db2);
+  if (applied.length === 0) {
+    return 0;
+  }
+  const lastBatch = applied.reduce((currentMax, { batch }) => Math.max(currentMax, Number(batch)), 0);
+  const migrationsToRollback = new Set(applied.filter(({ batch }) => Number(batch) === lastBatch).map(({ name }) => name));
+  let rolledBack = 0;
+  for (const migration of [...migrations].reverse()) {
+    if (!migrationsToRollback.has(migration.name)) {
+      continue;
+    }
+    options.onMigration?.(migration.name);
+    await migration.down(db2);
+    await db2.unsafe(`DELETE FROM ${MIGRATIONS_TABLE} WHERE name = $1`, [migration.name]);
+    rolledBack += 1;
+  }
+  return rolledBack;
+}
+async function freshDatabase(db2, migrations, options = {}) {
+  const applied = await getAppliedMigrations(db2);
+  const appliedNames = new Set(applied.map(({ name }) => name));
+  const appliedMigrations = migrations.filter(({ name }) => appliedNames.has(name));
+  for (const migration of [...appliedMigrations].reverse()) {
+    options.onMigration?.(migration.name);
+    await migration.down(db2);
+  }
+  if (appliedMigrations.length > 0) {
+    await db2.unsafe(`DELETE FROM ${MIGRATIONS_TABLE}`);
+  }
+  await migrateDatabase(db2, migrations, options);
+}
+// ../../src/core/database/model.ts
+var modelRepositories = new WeakMap;
+function resolveModelRepository(model) {
+  const repository = modelRepositories.get(model);
+  if (!repository) {
+    throw new Error(`${model.name}.repository() is not implemented.`);
+  }
+  return repository;
+}
+
+class Model {
+  attributes;
+  repository;
+  constructor(attributes, repository) {
+    this.attributes = attributes;
+    this.repository = repository;
+  }
+  get(key) {
+    return this.attributes[key];
+  }
+  get id() {
+    return this.attributes[this.primaryKey()];
+  }
+  toObject() {
+    return { ...this.attributes };
+  }
+  primaryKey() {
+    throw new Error(`${this.constructor.name}.primaryKey() is not implemented.`);
+  }
+  static repository() {
+    return resolveModelRepository(this);
+  }
+  static query() {
+    return resolveModelRepository(this).query();
+  }
+  static async find(id) {
+    const repository = resolveModelRepository(this);
+    const record = await repository.findById(id);
+    return record ? new this(record, repository) : null;
+  }
+  static async findOrFail(id, errorFactory) {
+    const repository = resolveModelRepository(this);
+    const record = await repository.findByIdOrThrow(id, errorFactory ?? ((value) => new Error(`Record ${String(value)} not found.`)));
+    return new this(record, repository);
+  }
+  static async all(options = {}) {
+    const repository = resolveModelRepository(this);
+    const rows = await repository.findAll(options);
+    return rows.map((row) => new this(row, repository));
+  }
+  static async firstWhere(where, options = {}) {
+    const repository = resolveModelRepository(this);
+    const rows = await repository.findAll({ ...options, where, limit: 1 });
+    const record = rows[0];
+    return record ? new this(record, repository) : null;
+  }
+  async loadHasMany(as, relation, childRepository, options = {}) {
+    const grouped = await childRepository.withConnection(this.repository.getConnection()).loadHasManyForParents([this.attributes], relation, options);
+    const loaded = grouped.get(this.attributes[relation.localKey]) ?? [];
+    return Object.assign(this, { [as]: loaded });
+  }
+  async loadBelongsTo(as, relation, parentRepository, options = {}) {
+    const grouped = await this.repository.loadBelongsToForParents([this.attributes], relation, parentRepository, options);
+    const loaded = grouped.get(this.attributes[relation.foreignKey]);
+    return Object.assign(this, { [as]: loaded });
+  }
+  mergeAttributes(patch) {
+    Object.assign(this.attributes, patch);
+    return this;
+  }
+}
+function registerModelRepository(model, repository) {
+  modelRepositories.set(model, repository);
+  return model;
+}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;
@@ -1181,7 +1439,7 @@ function mailer() {
 // ../../src/core/storage/storage.ts
 var {S3Client } = globalThis.Bun;
 import { mkdir, readFile, unlink, writeFile } from "fs/promises";
-import { dirname, join } from "path";
+import { dirname, join as join2 } from "path";
 
 class LocalStorageDriver {
   rootDirectory;
@@ -1189,7 +1447,7 @@ class LocalStorageDriver {
     this.rootDirectory = rootDirectory;
   }
   resolvePath(path) {
-    return join(this.rootDirectory, path.replace(/^\/+/, ""));
+    return join2(this.rootDirectory, path.replace(/^\/+/, ""));
   }
   async put(path, contents) {
     const absolutePath = this.resolvePath(path);
@@ -1336,9 +1594,9 @@ function isViewsEnabled() {
 }
 
 // ../../src/core/view/etaViewEngine.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { Eta } from "eta";
-var DEFAULT_VIEWS_DIRECTORY = join2(process.cwd(), "resources/views");
+var DEFAULT_VIEWS_DIRECTORY = join3(process.cwd(), "resources/views");
 // ../../src/core/view/htmlResponse.ts
 function htmlResponse(html, init = {}) {
   return new Response(html, {
@@ -2105,13 +2363,16 @@ class WebFormRequest {
   authorize(_request) {
     return true;
   }
+  validatePayload(payload) {
+    return this.parse(payload);
+  }
   async validate(request) {
     if (!await this.authorize(request)) {
       throw new ForbiddenError;
     }
     const payload = requestPrefersJson(request) ? await parseJsonBody(request, (body) => body) : await parseFormBody(request);
     try {
-      return this.parse(payload);
+      return this.validatePayload(payload);
     } catch (error) {
       if (error instanceof ValidationError) {
         throw error;
@@ -2145,12 +2406,94 @@ class AsyncQueue {
 function createQueue(driver) {
   return driver === "async" ? new AsyncQueue : new SyncQueue;
 }
+// ../../src/core/validation/rules.ts
+function required() {
+  return (field, value) => {
+    if (value === undefined || value === null || typeof value === "string" && value.trim() === "") {
+      return `"${field}" is required.`;
+    }
+    return;
+  };
+}
+function stringRule() {
+  return (field, value) => {
+    if (value === undefined || value === null) {
+      return;
+    }
+    if (typeof value !== "string") {
+      return `"${field}" must be a string.`;
+    }
+    return;
+  };
+}
+function minLength(minimum) {
+  return (field, value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    if (value.trim().length < minimum) {
+      return `"${field}" must be at least ${minimum} characters.`;
+    }
+    return;
+  };
+}
+function maxLength(maximum) {
+  return (field, value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    if (value.trim().length > maximum) {
+      return `"${field}" must be at most ${maximum} characters.`;
+    }
+    return;
+  };
+}
+function emailRule() {
+  return (field, value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    const normalized = value.trim();
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(normalized)) {
+      return `"${field}" must be a valid email address.`;
+    }
+    return;
+  };
+}
+function validateObject(payload, schema) {
+  if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new ValidationError("Request body must be a JSON object.");
+  }
+  const body = payload;
+  const errors = {};
+  const output = {};
+  for (const [field, rules] of Object.entries(schema)) {
+    const messages = rules.map((rule) => rule(field, body[field], body)).filter((message) => message !== undefined);
+    if (messages.length > 0) {
+      errors[field] = messages;
+      continue;
+    }
+    if (field in body && body[field] !== undefined) {
+      const rawValue = body[field];
+      output[field] = typeof rawValue === "string" ? rawValue.trim() : rawValue;
+    }
+  }
+  if (Object.keys(errors).length > 0) {
+    throw new ValidationError("The given data was invalid.", errors);
+  }
+  return output;
+}
 export {
   withErrorHandling,
+  validateObject,
+  stringRule,
   storageFacade as storage,
   securedBindRouteModel,
   runWithAuthUser,
+  rollbackDatabase,
   resolveService,
+  required,
+  registerModelRepository,
   queue,
   prometheusRegistry,
   policyGate,
@@ -2158,13 +2501,23 @@ export {
   paginatedResponse,
   normalizeMetricPath,
   noContentResponse,
+  minLength,
+  migrateDatabase,
+  maxLength,
   mailer,
   mail,
   log,
+  loadMigrationsFromDirectory,
   jsonResponse,
   isEtagEnabled,
+  indexHasManyRelation,
+  indexBelongsToRelation,
+  hasMany,
+  getMigrationStatus,
+  freshDatabase,
   events,
   etagFromResource,
+  emailRule,
   defineTable,
   currentAuthUser,
   createdResponse,
@@ -2172,6 +2525,7 @@ export {
   createMetricsMiddleware,
   config,
   cache,
+  belongsTo,
   auth,
   assertIfMatch,
   WebFormRequest,
@@ -2181,10 +2535,13 @@ export {
   SyncQueue,
   StorageManager,
   ServiceContainer,
+  RepositoryQuery,
   PrometheusRegistry,
   PreconditionFailedError,
+  PolicyGate,
   Policy,
   NotFoundError,
+  Model,
   Mailer,
   LogMailDriver,
   LocalStorageDriver,

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

@@ -1,7 +1,7 @@
 import type { ServiceProvider } from "../../bootstrap/contracts";
 declare const userRepositoryToken = "user.repository";
 declare const apiTokenRepositoryToken = "user.apiTokenRepository";
-declare const tokenServiceToken = "user.tokenService";
+declare const tokenServiceToken = "core.tokenService";
 declare const authServiceToken = "user.authService";
 declare const oauthIdentityRepositoryToken = "user.oauthIdentityRepository";
 declare const notificationRepositoryToken = "user.notificationRepository";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.3.0",
+  "version": "0.3.8",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",