@getstrata/core 1.1.1 → 1.1.3

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @getstrata/core changelog
 
+## 1.1.3
+
+- Eager with() arrays, OpenAPI mkdir, public-read/auth docs
+
+## 1.1.2
+
+- Product CLI helpers, file migrations, and job discovery.
+
+## Unreleased
+
+- `Job` tracks `static jobName` on construct so `queue.dispatch(new FooJob(), payload)` resolves a registry name.
+- The core migration runner is dialect-aware (placeholders, upsert, returning, timestamp column) so sqlite and mysql product apps can use `framework_migrations`. Import it from `@getstrata/core/database/migrations`.
+
 ## 1.1.1
 
 Fix generated app boot

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

@@ -14,6 +14,7 @@ interface ModelConstructor<TEntity extends object, PrimaryKey extends keyof TEnt
 }
 type AnyModel = Model<Record<string, unknown>, "id">;
 type RelatedRef<TRelated extends object, RelatedKey extends keyof TRelated & string> = RelatedModelClass<TRelated, RelatedKey> | string | (() => RelatedModelClass<TRelated, RelatedKey>);
+type RelationNameInput = string | readonly string[];
 type ModelObserver = {
     retrieved?: (model: AnyModel) => unknown;
     creating?: (model: AnyModel) => unknown;
@@ -36,7 +37,7 @@ declare class ModelQuery {
     readonly query: RepositoryQuery<Record<string, unknown>, "id">;
     private readonly eager;
     constructor(modelClass: object, query: RepositoryQuery<Record<string, unknown>, "id">);
-    with(...relations: string[]): this;
+    with(...relations: RelationNameInput[]): this;
     where(input: QueryWhere<object> | ((builder: import("./whereBuilder.ts").WhereBuilder<object>) => void)): this;
     orWhere(input: QueryWhere<object> | ((builder: import("./whereBuilder.ts").WhereBuilder<object>) => void)): this;
     orderBy(orderBy: QueryOptions<object>["orderBy"]): this;
@@ -124,7 +125,7 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     static query(this: object): ModelQuery;
     static newFromRecord(this: object, record: object, exists?: boolean): Model<Record<string, unknown>, "id">;
     static create(this: object, attributes: Record<string, unknown>, forced?: Record<string, unknown>): Promise<Model<Record<string, unknown>, "id">>;
-    static with(this: object, ...relations: string[]): ModelQuery;
+    static with(this: object, ...relations: RelationNameInput[]): ModelQuery;
     static withTrashed(this: object): ModelQuery;
     static onlyTrashed(this: object): ModelQuery;
     static chunk(this: object, count: number, callback: (models: Array<Model<Record<string, unknown>, "id">>) => Promise<boolean | void>): Promise<void>;
@@ -173,7 +174,7 @@ declare class Model<TEntity extends object, PrimaryKey extends keyof TEntity & s
     morphMany<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string, morphType?: string): MorphManyRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
     morphOne<TRelated extends object, RelatedKey extends keyof TRelated & string>(related: RelatedRef<TRelated, RelatedKey>, morphName: string, typeKey?: keyof TRelated & string, idKey?: keyof TRelated & string, morphType?: string): MorphOneRelationQuery<TEntity, PrimaryKey, TRelated, RelatedKey>;
     morphTo(relatedByType: Record<string, RelatedRef<Record<string, unknown>, "id">>, morphName?: string, typeKey?: keyof TEntity & string, idKey?: keyof TEntity & string): MorphToRelationQuery<TEntity, PrimaryKey>;
-    load(...names: string[]): Promise<this>;
+    load(...names: RelationNameInput[]): Promise<this>;
     loaded<T = unknown>(name: string): T | undefined;
     setLoaded(name: string, value: unknown): this;
     mergeAttributes(patch: Partial<TEntity>): this;

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

@@ -1,8 +1,10 @@
 type QueuePriority = "high" | "default" | "low";
 declare abstract class Job<TPayload extends object = object> {
+    static readonly jobName?: string;
     readonly maxAttempts?: number;
     readonly backoffMs?: number;
     readonly priority?: QueuePriority;
+    constructor();
     abstract handle(payload: TPayload): Promise<void>;
 }
 interface Queue {

package/dist/entries/database/migrations.js

@@ -4,6 +4,198 @@ import { readdir } from "fs/promises";
 import { join } from "path";
 import { pathToFileURL } from "url";
 
+// ../../src/core/runtime/asyncContextStore.ts
+import { AsyncLocalStorage } from "async_hooks";
+function createAsyncContextStore(key) {
+  const symbol = Symbol.for(key);
+  const globalRecord = globalThis;
+  const existing = globalRecord[symbol];
+  if (existing) {
+    return existing;
+  }
+  const store = new AsyncLocalStorage;
+  globalRecord[symbol] = store;
+  return store;
+}
+
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
+
+// ../../src/core/database/dialect.ts
+function assertSafeIdentifier(identifier) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
+  }
+  return identifier;
+}
+function quoteIdentifierFor(dialect, column) {
+  return dialect.quoteIdentifier(column);
+}
+var postgresDialect = {
+  driver: "pgsql",
+  placeholder(index) {
+    return `$${index}`;
+  },
+  quoteIdentifier(identifier) {
+    return `"${assertSafeIdentifier(identifier)}"`;
+  },
+  nowExpression() {
+    return "NOW()";
+  },
+  timestampValue(value) {
+    return value.toISOString();
+  },
+  returningClause(columns) {
+    return ` RETURNING ${columns}`;
+  },
+  ilikeOperator() {
+    return "ILIKE";
+  },
+  nullsLastSuffix() {
+    return " NULLS LAST";
+  },
+  castToText(expression) {
+    return `${expression}::text`;
+  },
+  upsertSuffix(conflictColumns, updateColumns) {
+    const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+    if (updateColumns.length === 0) {
+      return ` ON CONFLICT (${target}) DO NOTHING`;
+    }
+    const assignments = updateColumns.map((column) => {
+      const quoted = quoteIdentifierFor(this, column);
+      return `${quoted} = excluded.${quoted}`;
+    }).join(", ");
+    return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+  }
+};
+var mysqlDialect = {
+  driver: "mysql",
+  placeholder() {
+    return "?";
+  },
+  quoteIdentifier(identifier) {
+    return `\`${assertSafeIdentifier(identifier)}\``;
+  },
+  nowExpression() {
+    return "CURRENT_TIMESTAMP";
+  },
+  timestampValue(value) {
+    return value.toISOString().slice(0, 19).replace("T", " ");
+  },
+  returningClause() {
+    return "";
+  },
+  ilikeOperator() {
+    return "LIKE";
+  },
+  nullsLastSuffix() {
+    return "";
+  },
+  castToText(expression) {
+    return `CAST(${expression} AS CHAR)`;
+  },
+  upsertSuffix(conflictColumns, updateColumns) {
+    if (updateColumns.length === 0) {
+      const anchor = quoteIdentifierFor(this, conflictColumns[0] ?? "");
+      return ` ON DUPLICATE KEY UPDATE ${anchor} = ${anchor}`;
+    }
+    const assignments = updateColumns.map((column) => {
+      const quoted = quoteIdentifierFor(this, column);
+      return `${quoted} = VALUES(${quoted})`;
+    }).join(", ");
+    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+  }
+};
+var sqliteDialect = {
+  driver: "sqlite",
+  placeholder() {
+    return "?";
+  },
+  quoteIdentifier(identifier) {
+    return `"${assertSafeIdentifier(identifier)}"`;
+  },
+  nowExpression() {
+    return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
+  },
+  timestampValue(value) {
+    return value.toISOString();
+  },
+  returningClause(columns) {
+    return ` RETURNING ${columns}`;
+  },
+  ilikeOperator() {
+    return "LIKE";
+  },
+  nullsLastSuffix() {
+    return "";
+  },
+  castToText(expression) {
+    return `CAST(${expression} AS TEXT)`;
+  },
+  upsertSuffix(conflictColumns, updateColumns) {
+    const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+    if (updateColumns.length === 0) {
+      return ` ON CONFLICT (${target}) DO NOTHING`;
+    }
+    const assignments = updateColumns.map((column) => {
+      const quoted = quoteIdentifierFor(this, column);
+      return `${quoted} = excluded.${quoted}`;
+    }).join(", ");
+    return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+  }
+};
+var dialects = {
+  pgsql: postgresDialect,
+  mysql: mysqlDialect,
+  sqlite: sqliteDialect
+};
+var dialectContext = createAsyncContextStore("@getstrata/sqlDialect");
+var dialectOverride = null;
+function dialectFor(driver) {
+  return dialects[driver];
+}
+function currentSqlDialect() {
+  return dialectContext.getStore() ?? dialectOverride ?? dialectFor(resolveDatabaseDriver());
+}
+
 // ../../src/core/database/migrations/advisoryLock.ts
 var MIGRATION_LOCK_KEY = 42424242;
 async function withMigrationLock(db, callback, lockKey = MIGRATION_LOCK_KEY) {
@@ -17,15 +209,37 @@ async function withMigrationLock(db, callback, lockKey = MIGRATION_LOCK_KEY) {
 
 // ../../src/core/database/migrations/runner.ts
 var MIGRATIONS_TABLE = "framework_migrations";
+function migrationsNameColumn() {
+  return currentSqlDialect().driver === "mysql" ? "VARCHAR(255) PRIMARY KEY" : "TEXT PRIMARY KEY";
+}
+function migrationsRunOnColumn() {
+  const dialect = currentSqlDialect();
+  if (dialect.driver === "pgsql") {
+    return `TIMESTAMPTZ NOT NULL DEFAULT ${dialect.nowExpression()}`;
+  }
+  if (dialect.driver === "mysql") {
+    return `DATETIME NOT NULL DEFAULT ${dialect.nowExpression()}`;
+  }
+  return "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP";
+}
 async function ensureMigrationsTable(db) {
   await db.unsafe(`
     CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
-      name TEXT PRIMARY KEY,
+      name ${migrationsNameColumn()},
       batch INTEGER NOT NULL,
-      run_on TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      run_on ${migrationsRunOnColumn()}
     )
   `);
 }
+async function recordAppliedMigration(db, name, batch) {
+  const dialect = currentSqlDialect();
+  const inserted = await db.unsafe(`INSERT INTO ${MIGRATIONS_TABLE} (name, batch) VALUES (${dialect.placeholder(1)}, ${dialect.placeholder(2)})${dialect.upsertSuffix(["name"], [])}${dialect.returningClause("name")}`, [name, batch]);
+  if (dialect.returningClause("name")) {
+    return inserted.length > 0;
+  }
+  const rows = await db.unsafe(`SELECT batch FROM ${MIGRATIONS_TABLE} WHERE name = ${dialect.placeholder(1)}`, [name]);
+  return rows.some((row) => Number(row.batch) === batch);
+}
 async function getAppliedMigrations(db) {
   await ensureMigrationsTable(db);
   return await db.unsafe(`
@@ -61,8 +275,8 @@ async function runPendingMigrations(db, migrations, options = {}) {
   for (const migration of pendingMigrations) {
     options.onMigration?.(migration.name);
     await migration.up(db);
-    const inserted = await db.unsafe(`INSERT INTO ${MIGRATIONS_TABLE} (name, batch) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING RETURNING name`, [migration.name, nextBatch]);
-    if (inserted.length === 0) {
+    const recorded = await recordAppliedMigration(db, migration.name, nextBatch);
+    if (!recorded) {
       throw new Error(`Migration ${migration.name} was applied but not recorded.`);
     }
   }
@@ -89,7 +303,7 @@ async function rollbackDatabase(db, migrations, options = {}) {
     }
     options.onMigration?.(migration.name);
     await migration.down(db);
-    await db.unsafe(`DELETE FROM ${MIGRATIONS_TABLE} WHERE name = $1`, [migration.name]);
+    await db.unsafe(`DELETE FROM ${MIGRATIONS_TABLE} WHERE name = ${currentSqlDialect().placeholder(1)}`, [migration.name]);
     rolledBack += 1;
   }
   return rolledBack;

package/dist/entries/database/model.js

@@ -1469,6 +1469,25 @@ var namedModels = new Map;
 var modelGlobalScopes = new WeakMap;
 var modelObservers = new WeakMap;
 var modelBooted = new WeakSet;
+function flattenRelationNames(relations) {
+  const names = [];
+  for (const item of relations) {
+    if (typeof item === "string") {
+      if (item.length > 0) {
+        names.push(item);
+      }
+      continue;
+    }
+    if (Array.isArray(item)) {
+      for (const nested of item) {
+        if (typeof nested === "string" && nested.length > 0) {
+          names.push(nested);
+        }
+      }
+    }
+  }
+  return names;
+}
 async function runObservers(model, hook) {
   const observers = modelObservers.get(model.constructor) ?? [];
   for (const observer of observers) {
@@ -1725,7 +1744,7 @@ class ModelQuery {
     const statics = modelStatics(this.modelClass);
     ensureBooted(this.modelClass);
     const dummy = statics.newFromRecord({}, false);
-    for (const path of relations) {
+    for (const path of flattenRelationNames(relations)) {
       const name = path.split(".")[0] ?? path;
       const method = dummy[name];
       if (typeof method !== "function") {
@@ -2387,7 +2406,7 @@ class Model {
     }));
   }
   async load(...names) {
-    for (const name of names) {
+    for (const name of flattenRelationNames(names)) {
       if (name.includes(".")) {
         await loadNested(this, name);
         continue;

package/dist/entries/jobs/exportAuditLogsJob.js

@@ -615,11 +615,55 @@ class Logger {
 }
 var appLogger = new Logger("app");
 
+// ../../src/core/queue/jobRegistry.ts
+class JobRegistry {
+  factories = new Map;
+  instances = new WeakMap;
+  register(name, factory) {
+    this.factories.set(name, factory);
+  }
+  resolveName(job) {
+    return this.instances.get(job);
+  }
+  track(name, job) {
+    this.instances.set(job, name);
+    return job;
+  }
+  create(name) {
+    const factory = this.factories.get(name);
+    if (!factory) {
+      return;
+    }
+    return factory();
+  }
+  names() {
+    return [...this.factories.keys()];
+  }
+}
+var JOB_REGISTRY_KEY = Symbol.for("@getstrata/jobRegistry");
+function readSharedJobRegistry() {
+  const globalRegistry = globalThis[JOB_REGISTRY_KEY];
+  if (globalRegistry) {
+    return globalRegistry;
+  }
+  const registry = new JobRegistry;
+  globalThis[JOB_REGISTRY_KEY] = registry;
+  return registry;
+}
+var jobRegistry = readSharedJobRegistry();
+
 // ../../src/core/queue/index.ts
 class Job {
+  static jobName;
   maxAttempts;
   backoffMs;
   priority;
+  constructor() {
+    const jobName = this.constructor.jobName;
+    if (jobName) {
+      jobRegistry.track(jobName, this);
+    }
+  }
 }
 
 class SyncQueue {

package/dist/entries/jobs/invalidateCacheTagsJob.js

@@ -1,9 +1,53 @@
 // @bun
+// ../../src/core/queue/jobRegistry.ts
+class JobRegistry {
+  factories = new Map;
+  instances = new WeakMap;
+  register(name, factory) {
+    this.factories.set(name, factory);
+  }
+  resolveName(job) {
+    return this.instances.get(job);
+  }
+  track(name, job) {
+    this.instances.set(job, name);
+    return job;
+  }
+  create(name) {
+    const factory = this.factories.get(name);
+    if (!factory) {
+      return;
+    }
+    return factory();
+  }
+  names() {
+    return [...this.factories.keys()];
+  }
+}
+var JOB_REGISTRY_KEY = Symbol.for("@getstrata/jobRegistry");
+function readSharedJobRegistry() {
+  const globalRegistry = globalThis[JOB_REGISTRY_KEY];
+  if (globalRegistry) {
+    return globalRegistry;
+  }
+  const registry = new JobRegistry;
+  globalThis[JOB_REGISTRY_KEY] = registry;
+  return registry;
+}
+var jobRegistry = readSharedJobRegistry();
+
 // ../../src/core/queue/index.ts
 class Job {
+  static jobName;
   maxAttempts;
   backoffMs;
   priority;
+  constructor() {
+    const jobName = this.constructor.jobName;
+    if (jobName) {
+      jobRegistry.track(jobName, this);
+    }
+  }
 }
 
 class SyncQueue {

package/dist/entries/queue.js

@@ -1,9 +1,53 @@
 // @bun
+// ../../src/core/queue/jobRegistry.ts
+class JobRegistry {
+  factories = new Map;
+  instances = new WeakMap;
+  register(name, factory) {
+    this.factories.set(name, factory);
+  }
+  resolveName(job) {
+    return this.instances.get(job);
+  }
+  track(name, job) {
+    this.instances.set(job, name);
+    return job;
+  }
+  create(name) {
+    const factory = this.factories.get(name);
+    if (!factory) {
+      return;
+    }
+    return factory();
+  }
+  names() {
+    return [...this.factories.keys()];
+  }
+}
+var JOB_REGISTRY_KEY = Symbol.for("@getstrata/jobRegistry");
+function readSharedJobRegistry() {
+  const globalRegistry = globalThis[JOB_REGISTRY_KEY];
+  if (globalRegistry) {
+    return globalRegistry;
+  }
+  const registry = new JobRegistry;
+  globalThis[JOB_REGISTRY_KEY] = registry;
+  return registry;
+}
+var jobRegistry = readSharedJobRegistry();
+
 // ../../src/core/queue/index.ts
 class Job {
+  static jobName;
   maxAttempts;
   backoffMs;
   priority;
+  constructor() {
+    const jobName = this.constructor.jobName;
+    if (jobName) {
+      jobRegistry.track(jobName, this);
+    }
+  }
 }
 
 class SyncQueue {

package/dist/index.js

@@ -5082,15 +5082,37 @@ import { readdir } from "fs/promises";
 import { join } from "path";
 import { pathToFileURL } from "url";
 var MIGRATIONS_TABLE = "framework_migrations";
+function migrationsNameColumn() {
+  return currentSqlDialect().driver === "mysql" ? "VARCHAR(255) PRIMARY KEY" : "TEXT PRIMARY KEY";
+}
+function migrationsRunOnColumn() {
+  const dialect = currentSqlDialect();
+  if (dialect.driver === "pgsql") {
+    return `TIMESTAMPTZ NOT NULL DEFAULT ${dialect.nowExpression()}`;
+  }
+  if (dialect.driver === "mysql") {
+    return `DATETIME NOT NULL DEFAULT ${dialect.nowExpression()}`;
+  }
+  return "TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP";
+}
 async function ensureMigrationsTable(db) {
   await db.unsafe(`
     CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
-      name TEXT PRIMARY KEY,
+      name ${migrationsNameColumn()},
       batch INTEGER NOT NULL,
-      run_on TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      run_on ${migrationsRunOnColumn()}
     )
   `);
 }
+async function recordAppliedMigration(db, name, batch) {
+  const dialect = currentSqlDialect();
+  const inserted = await db.unsafe(`INSERT INTO ${MIGRATIONS_TABLE} (name, batch) VALUES (${dialect.placeholder(1)}, ${dialect.placeholder(2)})${dialect.upsertSuffix(["name"], [])}${dialect.returningClause("name")}`, [name, batch]);
+  if (dialect.returningClause("name")) {
+    return inserted.length > 0;
+  }
+  const rows = await db.unsafe(`SELECT batch FROM ${MIGRATIONS_TABLE} WHERE name = ${dialect.placeholder(1)}`, [name]);
+  return rows.some((row) => Number(row.batch) === batch);
+}
 async function getAppliedMigrations(db) {
   await ensureMigrationsTable(db);
   return await db.unsafe(`
@@ -5126,8 +5148,8 @@ async function runPendingMigrations(db, migrations, options = {}) {
   for (const migration of pendingMigrations) {
     options.onMigration?.(migration.name);
     await migration.up(db);
-    const inserted = await db.unsafe(`INSERT INTO ${MIGRATIONS_TABLE} (name, batch) VALUES ($1, $2) ON CONFLICT (name) DO NOTHING RETURNING name`, [migration.name, nextBatch]);
-    if (inserted.length === 0) {
+    const recorded = await recordAppliedMigration(db, migration.name, nextBatch);
+    if (!recorded) {
       throw new Error(`Migration ${migration.name} was applied but not recorded.`);
     }
   }
@@ -5154,7 +5176,7 @@ async function rollbackDatabase(db, migrations, options = {}) {
     }
     options.onMigration?.(migration.name);
     await migration.down(db);
-    await db.unsafe(`DELETE FROM ${MIGRATIONS_TABLE} WHERE name = $1`, [migration.name]);
+    await db.unsafe(`DELETE FROM ${MIGRATIONS_TABLE} WHERE name = ${currentSqlDialect().placeholder(1)}`, [migration.name]);
     rolledBack += 1;
   }
   return rolledBack;
@@ -5846,6 +5868,25 @@ var namedModels = new Map;
 var modelGlobalScopes = new WeakMap;
 var modelObservers = new WeakMap;
 var modelBooted = new WeakSet;
+function flattenRelationNames(relations) {
+  const names = [];
+  for (const item of relations) {
+    if (typeof item === "string") {
+      if (item.length > 0) {
+        names.push(item);
+      }
+      continue;
+    }
+    if (Array.isArray(item)) {
+      for (const nested of item) {
+        if (typeof nested === "string" && nested.length > 0) {
+          names.push(nested);
+        }
+      }
+    }
+  }
+  return names;
+}
 async function runObservers(model, hook) {
   const observers = modelObservers.get(model.constructor) ?? [];
   for (const observer of observers) {
@@ -6102,7 +6143,7 @@ class ModelQuery {
     const statics = modelStatics(this.modelClass);
     ensureBooted(this.modelClass);
     const dummy = statics.newFromRecord({}, false);
-    for (const path of relations) {
+    for (const path of flattenRelationNames(relations)) {
       const name = path.split(".")[0] ?? path;
       const method = dummy[name];
       if (typeof method !== "function") {
@@ -6764,7 +6805,7 @@ class Model {
     }));
   }
   async load(...names) {
-    for (const name of names) {
+    for (const name of flattenRelationNames(names)) {
       if (name.includes(".")) {
         await loadNested(this, name);
         continue;
@@ -10387,31 +10428,6 @@ class Notification {
     return null;
   }
 }
-// ../../src/core/queue/index.ts
-class Job {
-  maxAttempts;
-  backoffMs;
-  priority;
-}
-
-class SyncQueue {
-  async dispatch(job, payload) {
-    await job.handle(payload);
-  }
-}
-
-class AsyncQueue {
-  async dispatch(job, payload) {
-    setTimeout(() => {
-      job.handle(payload).catch((error) => {
-        console.error("[AsyncQueue] Job failed:", error);
-      });
-    }, 0);
-  }
-}
-function createQueue(driver) {
-  return driver === "async" ? new AsyncQueue : new SyncQueue;
-}
 // ../../src/core/queue/jobRegistry.ts
 class JobRegistry {
   factories = new Map;
@@ -10448,6 +10464,39 @@ function readSharedJobRegistry() {
   return registry;
 }
 var jobRegistry = readSharedJobRegistry();
+
+// ../../src/core/queue/index.ts
+class Job {
+  static jobName;
+  maxAttempts;
+  backoffMs;
+  priority;
+  constructor() {
+    const jobName = this.constructor.jobName;
+    if (jobName) {
+      jobRegistry.track(jobName, this);
+    }
+  }
+}
+
+class SyncQueue {
+  async dispatch(job, payload) {
+    await job.handle(payload);
+  }
+}
+
+class AsyncQueue {
+  async dispatch(job, payload) {
+    setTimeout(() => {
+      job.handle(payload).catch((error) => {
+        console.error("[AsyncQueue] Job failed:", error);
+      });
+    }, 0);
+  }
+}
+function createQueue(driver) {
+  return driver === "async" ? new AsyncQueue : new SyncQueue;
+}
 // ../../src/core/queue/failedJobTable.ts
 var failedJobTable = defineTable({
   name: "failed_job",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",