@getstrata/core 0.3.2 → 0.3.8

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/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/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,17 @@
  */
 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";
@@ -33,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

@@ -1024,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;
@@ -1279,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;
@@ -1287,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);
@@ -1434,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, {
@@ -2203,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;
@@ -2243,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,
@@ -2256,16 +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,
@@ -2286,8 +2538,10 @@ export {
   RepositoryQuery,
   PrometheusRegistry,
   PreconditionFailedError,
+  PolicyGate,
   Policy,
   NotFoundError,
+  Model,
   Mailer,
   LogMailDriver,
   LocalStorageDriver,

package/package.json

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