@getstrata/core 0.5.41 → 0.5.43

package/dist/entries/queue/publicQueue.js

@@ -270,6 +270,14 @@ function appendWhereParts(tableName, where, params) {
   }
   return clauses.join(" AND ");
 }
+function buildWhereClause(tableName, where = {}) {
+  const params = [];
+  const body = appendWhereParts(tableName, where, params);
+  return {
+    clause: body.length > 0 ? ` WHERE ${body}` : "",
+    params
+  };
+}
 function buildWhereNodeClause(tableName, node, params) {
   if ("where" in node) {
     return appendWhereParts(tableName, node.where, params);
@@ -572,6 +580,30 @@ function buildDeleteByIdQuery(table, id) {
 }
 
 // ../../src/core/database/relationships.ts
+function hasMany(definition) {
+  return {
+    type: "hasMany",
+    ...definition
+  };
+}
+function hasOne(definition) {
+  return {
+    type: "hasOne",
+    ...definition
+  };
+}
+function belongsTo(definition) {
+  return {
+    type: "belongsTo",
+    ...definition
+  };
+}
+function belongsToMany(definition) {
+  return {
+    type: "belongsToMany",
+    ...definition
+  };
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
   for (const parent of parents) {
@@ -587,6 +619,15 @@ function indexHasManyRelation(parents, children, relation) {
   }
   return groups;
 }
+function indexHasOneRelation(parents, children, relation) {
+  const grouped = indexHasManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
@@ -602,6 +643,45 @@ function indexBelongsToRelation(children, parents, relation) {
   }
   return result;
 }
+function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
+  const relatedById = new Map;
+  for (const related of relatedRows) {
+    relatedById.set(related[relation.relatedKey], related);
+  }
+  const groups = new Map;
+  for (const parent of parents) {
+    groups.set(parent[relation.parentKey], []);
+  }
+  for (const pivot of pivotRows) {
+    const parentId = pivot[relation.foreignPivotKey];
+    const relatedId = pivot[relation.relatedPivotKey];
+    const group = groups.get(parentId);
+    const related = relatedById.get(relatedId);
+    if (!group || !related) {
+      continue;
+    }
+    group.push(related);
+  }
+  return groups;
+}
+function morphMany(definition) {
+  return {
+    type: "morphMany",
+    ...definition
+  };
+}
+function morphOne(definition) {
+  return {
+    type: "morphOne",
+    ...definition
+  };
+}
+function morphTo(definition) {
+  return {
+    type: "morphTo",
+    ...definition
+  };
+}
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
   for (const parent of parents) {
@@ -620,6 +700,15 @@ function indexMorphManyRelation(parents, children, relation) {
   }
   return groups;
 }
+function indexMorphOneRelation(parents, children, relation) {
+  const grouped = indexMorphManyRelation(parents, children, relation);
+  const result = new Map;
+  for (const parent of parents) {
+    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    result.set(parent[relation.localKey], matches[0]);
+  }
+  return result;
+}
 function indexMorphToRelation(children, parentsByType, relation) {
   const result = new Map;
   for (const child of children) {
@@ -640,9 +729,15 @@ function indexMorphToRelation(children, parentsByType, relation) {
 var boundConnectionHolder = {
   connection: null
 };
+function bindDatabaseConnection(connection) {
+  boundConnectionHolder.connection = connection;
+}
 function getBoundDatabaseConnection() {
   return boundConnectionHolder.connection;
 }
+function resetBoundDatabaseConnection() {
+  boundConnectionHolder.connection = null;
+}
 
 // ../../src/core/runtime/asyncContextStore.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -660,9 +755,15 @@ function createAsyncContextStore(key) {
 
 // ../../src/core/database/connectionContext.ts
 var activeConnection = createAsyncContextStore("@getstrata/databaseConnectionContext");
+function runWithDatabaseConnection(connection, callback) {
+  return activeConnection.run(connection, callback);
+}
 function getActiveDatabaseConnection(fallback) {
   return activeConnection.getStore() ?? fallback;
 }
+function hasActiveDatabaseConnection() {
+  return activeConnection.getStore() !== undefined;
+}
 
 // ../../src/core/database/queryProxy.ts
 var POOL_CONNECTION_METHODS = new Set(["begin", "close", "connect"]);
@@ -699,6 +800,12 @@ function registerDefaultDatabasePool(connection) {
   defaultPool.connection = connection;
   defaultQuery.connection = createDatabaseQueryProxy(connection);
 }
+function getDefaultDatabasePool() {
+  if (!defaultPool.connection) {
+    throw new Error("Default database pool is not registered. Call registerDefaultDatabasePool() during app bootstrap.");
+  }
+  return defaultPool.connection;
+}
 function getDefaultDatabaseQuery() {
   if (!defaultQuery.connection) {
     throw new Error("Default database query handle is not registered. Call registerDefaultDatabasePool() during app bootstrap.");
@@ -1276,10 +1383,327 @@ class BaseRepository {
   }
 }
 var baseRepository_default = BaseRepository;
+// ../../src/core/database/connection.ts
+function createDatabaseConnection(source) {
+  return {
+    async unsafe(query, params = []) {
+      return await source.unsafe(query, params);
+    }
+  };
+}
 // ../../src/core/database/model.ts
 var modelRepositories = new WeakMap;
 var modelGlobalScopes = new WeakMap;
 var modelBooted = new WeakSet;
+function resolveModelRepository(model) {
+  const repository = modelRepositories.get(model);
+  if (!repository) {
+    throw new Error(`${model.name}.repository() is not implemented.`);
+  }
+  return repository;
+}
+function modelStatics(model) {
+  return model;
+}
+function ensureBooted(model) {
+  if (modelBooted.has(model)) {
+    return;
+  }
+  modelBooted.add(model);
+  const boot = model.boot;
+  if (typeof boot === "function") {
+    boot.call(model);
+  }
+}
+function getGlobalScopes(model) {
+  return modelGlobalScopes.get(model) ?? [];
+}
+function hydrateValue(value, cast) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  switch (cast) {
+    case "date":
+    case "datetime":
+      return value instanceof Date ? value : new Date(String(value));
+    case "json":
+      return typeof value === "string" ? JSON.parse(value) : value;
+    case "bool":
+    case "boolean":
+      return value === true || value === 1 || value === "1" || value === "true";
+    default:
+      return value;
+  }
+}
+function dehydrateValue(value, cast) {
+  if (value === null || value === undefined) {
+    return value;
+  }
+  switch (cast) {
+    case "date":
+    case "datetime":
+      return value instanceof Date ? value : new Date(String(value));
+    case "json":
+      return typeof value === "string" ? value : JSON.stringify(value);
+    case "bool":
+    case "boolean":
+      return Boolean(value);
+    default:
+      return value;
+  }
+}
+function filterMassAssignable(fillable, guarded, input) {
+  const resolvedGuarded = guarded ?? true;
+  if (fillable && fillable.length > 0) {
+    const allowed = new Set(fillable);
+    return Object.fromEntries(Object.entries(input).filter(([key]) => allowed.has(key)));
+  }
+  if (resolvedGuarded === true || resolvedGuarded.includes("*")) {
+    return {};
+  }
+  const blocked = new Set(resolvedGuarded);
+  return Object.fromEntries(Object.entries(input).filter(([key]) => !blocked.has(key)));
+}
+function applyCasts(values, casts, direction) {
+  if (Object.keys(casts).length === 0) {
+    return values;
+  }
+  const result = { ...values };
+  const castFn = direction === "hydrate" ? hydrateValue : dehydrateValue;
+  for (const [key, cast] of Object.entries(casts)) {
+    if (key in result && cast) {
+      result[key] = castFn(result[key], cast);
+    }
+  }
+  return result;
+}
+function applyTimestampsOnCreate(columns, values, enabled) {
+  if (!enabled) {
+    return values;
+  }
+  const now = new Date;
+  const result = { ...values };
+  if (columns.includes("created_at")) {
+    result.created_at = now;
+  }
+  if (columns.includes("updated_at")) {
+    result.updated_at = now;
+  }
+  return result;
+}
+function applyTimestampsOnUpdate(columns, values, enabled) {
+  if (!enabled) {
+    return values;
+  }
+  const result = { ...values };
+  if (columns.includes("updated_at")) {
+    result.updated_at = new Date;
+  }
+  return result;
+}
+
+class Model {
+  attributes;
+  repository;
+  static $fillable;
+  static $guarded;
+  static $casts = {};
+  static $timestamps = true;
+  _exists;
+  constructor(attributes, repository, exists = true) {
+    this.attributes = attributes;
+    this.repository = repository;
+    this._exists = exists;
+  }
+  get $exists() {
+    return this._exists;
+  }
+  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 primaryKeyField() {
+    return resolveModelRepository(this).getTable().primaryKey;
+  }
+  static hydrateAttributes(attributes) {
+    const casts = modelStatics(this).$casts ?? {};
+    return applyCasts(attributes, casts, "hydrate");
+  }
+  static dehydrateAttributes(attributes) {
+    const casts = modelStatics(this).$casts ?? {};
+    return applyCasts(attributes, casts, "dehydrate");
+  }
+  static fromRecord(record, repository, exists = true) {
+    const statics = modelStatics(this);
+    const hydrated = statics.hydrateAttributes(record);
+    return new statics(hydrated, repository, exists);
+  }
+  static boot() {}
+  static addGlobalScope(_name, scope) {
+    ensureBooted(this);
+    const existing = modelGlobalScopes.get(this) ?? [];
+    modelGlobalScopes.set(this, [
+      ...existing,
+      scope
+    ]);
+  }
+  static repository() {
+    return resolveModelRepository(this);
+  }
+  static query() {
+    ensureBooted(this);
+    const repository = resolveModelRepository(this);
+    let query = repository.query();
+    for (const scope of getGlobalScopes(this)) {
+      query = scope(query);
+    }
+    return query;
+  }
+  static async create(attributes) {
+    const statics = modelStatics(this);
+    ensureBooted(this);
+    const repository = resolveModelRepository(this);
+    const table = repository.getTable();
+    const timestamps = statics.$timestamps ?? true;
+    const assignable = filterMassAssignable(statics.$fillable, statics.$guarded, attributes);
+    const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
+    const payload = statics.dehydrateAttributes(withTimestamps);
+    const record = await repository.create(payload);
+    return statics.fromRecord(record, repository, true);
+  }
+  static async find(id) {
+    const statics = modelStatics(this);
+    const repository = resolveModelRepository(this);
+    const primaryKey = repository.getTable().primaryKey;
+    const record = await Model.query.call(this).where({ [primaryKey]: id }).first();
+    return record ? statics.fromRecord(record, repository, true) : null;
+  }
+  static async findOrFail(id, errorFactory) {
+    const model = await Model.find.call(this, id);
+    if (model) {
+      return model;
+    }
+    throw errorFactory?.(id) ?? new NotFoundError(`${this.name} ${String(id)} not found.`);
+  }
+  static async all(options = {}) {
+    const statics = modelStatics(this);
+    const repository = resolveModelRepository(this);
+    let query = Model.query.call(this);
+    if (options.orderBy) {
+      query = query.orderBy(options.orderBy);
+    }
+    if (options.limit !== undefined) {
+      query = query.limit(options.limit);
+    }
+    const rows = await query.get();
+    return rows.map((row) => statics.fromRecord(row, repository, true));
+  }
+  static async firstWhere(where, options = {}) {
+    const statics = modelStatics(this);
+    const repository = resolveModelRepository(this);
+    let query = Model.query.call(this).where(where);
+    if (options.orderBy) {
+      query = query.orderBy(options.orderBy);
+    }
+    const record = await query.first();
+    return record ? statics.fromRecord(record, repository, true) : null;
+  }
+  async save() {
+    const ModelClass = modelStatics(this.constructor);
+    const timestamps = ModelClass.$timestamps ?? true;
+    const casts = ModelClass.$casts ?? {};
+    const table = this.repository.getTable();
+    if (this.$exists) {
+      const changes = applyTimestampsOnUpdate(table.columns, applyCasts(this.attributes, casts, "dehydrate"), timestamps);
+      const record2 = await this.repository.updateByIdOrThrow(this.id, changes);
+      this.attributes = ModelClass.hydrateAttributes(record2);
+      return this;
+    }
+    const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, this.attributes);
+    const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
+    const payload = ModelClass.dehydrateAttributes(withTimestamps);
+    const record = await this.repository.create(payload);
+    this.attributes = ModelClass.hydrateAttributes(record);
+    this._exists = true;
+    return this;
+  }
+  async update(changes) {
+    const ModelClass = modelStatics(this.constructor);
+    const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, changes);
+    Object.assign(this.attributes, assignable);
+    return await this.save();
+  }
+  async delete() {
+    if (resolveSoftDeleteColumn(this.repository.getTable())) {
+      return await this.repository.deleteById(this.id);
+    }
+    return await this.repository.forceDeleteById(this.id);
+  }
+  async forceDelete() {
+    return await this.repository.forceDeleteById(this.id);
+  }
+  async restore() {
+    const ModelClass = modelStatics(this.constructor);
+    const record = await this.repository.restoreById(this.id);
+    if (!record) {
+      return null;
+    }
+    this.attributes = ModelClass.hydrateAttributes(record);
+    return this;
+  }
+  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 loadHasOne(as, relation, childRepository, options = {}) {
+    const loaded = await this.loadHasMany(as, relation, childRepository, { ...options, limit: 1 });
+    const value = loaded[as]?.[0];
+    return Object.assign(this, { [as]: value });
+  }
+  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 });
+  }
+  async loadBelongsToMany(as, relation, relatedRepository, options = {}) {
+    const connection = this.repository.getConnection();
+    const parentId = this.attributes[relation.parentKey];
+    const pivotRows = await connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} = $1`, [parentId]);
+    if (pivotRows.length === 0) {
+      return Object.assign(this, { [as]: [] });
+    }
+    const relatedIds = [
+      ...new Set(pivotRows.map((row) => row[relation.relatedPivotKey]))
+    ];
+    const relatedRows = await relatedRepository.withConnection(connection).findAll({
+      ...options,
+      where: {
+        [relation.relatedKey]: relatedIds
+      }
+    });
+    const grouped = indexBelongsToManyRelation([this.attributes], pivotRows, relatedRows, relation);
+    const loaded = grouped.get(parentId) ?? [];
+    return Object.assign(this, { [as]: loaded });
+  }
+  mergeAttributes(patch) {
+    Object.assign(this.attributes, patch);
+    return this;
+  }
+}
+function registerModelRepository(model, repository) {
+  modelRepositories.set(model, repository);
+  ensureBooted(model);
+  return model;
+}
 // ../../src/core/database/schema/columnDefinition.ts
 class ColumnDefinition {
   name;
@@ -1501,6 +1925,45 @@ class Blueprint {
     });
   }
 }
+// ../../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/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -1845,10 +2308,42 @@ class SchemaBuilder {
     }
   }
 }
+
+class Schema {
+  static builder(driver) {
+    return new SchemaBuilder(driver ?? resolveDatabaseDriver());
+  }
+  static async run(db, driver, callback) {
+    const schema = Schema.builder(driver);
+    await callback(schema);
+    await schema.execute(db);
+  }
+}
+function createSchemaBuilder(db, driver) {
+  const builder = Schema.builder(driver);
+  return Object.assign(builder, {
+    async commit() {
+      await builder.execute(db);
+    }
+  });
+}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;
 }
+// ../../src/core/database/transaction.ts
+function supportsTransactions(connection) {
+  return typeof connection.begin === "function";
+}
+async function runInTransaction(operation) {
+  const pool = resolveRepositoryConnection();
+  if (!supportsTransactions(pool)) {
+    throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
+  }
+  return await pool.begin(async (transaction) => {
+    return await operation(createDatabaseConnection(transaction));
+  });
+}
 // ../../src/core/queue/failedJobTable.ts
 var failedJobTable = defineTable({
   name: "failed_job",
@@ -2116,6 +2611,18 @@ class QueueWorker {
     this.client.close();
   }
 }
+async function countPendingQueueJobs(redisUrl) {
+  const client = new RedisClient(redisUrl);
+  try {
+    let total = 0;
+    for (const queueKey of QUEUE_KEYS) {
+      total += await client.llen(queueKey);
+    }
+    return total;
+  } finally {
+    client.close();
+  }
+}
 
 // ../../src/core/queue/resilientQueue.ts
 class ResilientQueue {