@getstrata/core 0.5.97 → 0.5.99

package/dist/entries/database/factory.js

@@ -1,18 +1,164 @@
 // @bun
+// ../../src/core/database/inflection.ts
+function singularize(word) {
+  if (word.endsWith("ies") && word.length > 3) {
+    return `${word.slice(0, -3)}y`;
+  }
+  if (/(ses|xes|zes|ches|shes)$/i.test(word)) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !word.endsWith("ss")) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function foreignKeyFromTable(tableName) {
+  return `${singularize(tableName)}_id`;
+}
+function pivotTableName(leftTable, rightTable) {
+  return [singularize(leftTable), singularize(rightTable)].sort().join("_");
+}
+
 // ../../src/core/database/factory.ts
+function inferFactoryForeignKey(parent, explicit) {
+  if (explicit) {
+    if (explicit.endsWith("_id")) {
+      return explicit;
+    }
+    return `${explicit}_id`;
+  }
+  if (typeof parent.getRepository === "function") {
+    return foreignKeyFromTable(parent.getRepository().getTable().name);
+  }
+  throw new Error("Factory.for() requires a foreign key or a parent Model.");
+}
+
 class Factory {
-  constructor() {}
+  quantity = 1;
+  counted = false;
+  sequenceIndex = 0;
+  stateTransforms = [];
+  sequenceItems = [];
+  parentAssociations = [];
+  children = [];
+  afterMakingCallbacks = [];
+  afterCreatingCallbacks = [];
+  model;
   definition() {
     throw new Error("Factory definition must be implemented by subclass.");
   }
+  clone() {
+    const next = Object.create(Object.getPrototypeOf(this));
+    Object.assign(next, this);
+    next.stateTransforms = [...this.stateTransforms];
+    next.sequenceItems = [...this.sequenceItems];
+    next.parentAssociations = [...this.parentAssociations];
+    next.children = [...this.children];
+    next.afterMakingCallbacks = [...this.afterMakingCallbacks];
+    next.afterCreatingCallbacks = [...this.afterCreatingCallbacks];
+    return next;
+  }
+  count(quantity) {
+    if (!Number.isInteger(quantity) || quantity < 1) {
+      throw new Error("Factory.count() requires a positive integer.");
+    }
+    const next = this.clone();
+    next.quantity = quantity;
+    next.counted = true;
+    return next;
+  }
+  state(state) {
+    const next = this.clone();
+    next.stateTransforms = [...this.stateTransforms, state];
+    return next;
+  }
+  sequence(...items) {
+    if (items.length === 0) {
+      throw new Error("Factory.sequence() requires at least one attribute set.");
+    }
+    const next = this.clone();
+    next.sequenceItems = [...this.sequenceItems, ...items];
+    return next;
+  }
+  for(parent, foreignKey) {
+    if (parent.id === undefined || parent.id === null) {
+      throw new Error("Factory.for() requires a parent with an id.");
+    }
+    const key = inferFactoryForeignKey(parent, foreignKey);
+    const next = this.clone();
+    next.parentAssociations = [...this.parentAssociations, { foreignKey: key, value: parent.id }];
+    return next;
+  }
+  recycle(parent, foreignKey) {
+    return this.for(parent, foreignKey);
+  }
+  afterMaking(callback) {
+    const next = this.clone();
+    next.afterMakingCallbacks = [...this.afterMakingCallbacks, callback];
+    return next;
+  }
+  afterCreating(callback) {
+    const next = this.clone();
+    next.afterCreatingCallbacks = [...this.afterCreatingCallbacks, callback];
+    return next;
+  }
+  has(factory, foreignKey) {
+    const next = this.clone();
+    next.children = [
+      ...this.children,
+      { factory, foreignKey }
+    ];
+    return next;
+  }
   make(overrides = {}) {
-    return {
-      ...this.definition(),
+    if (!this.counted) {
+      return this.makeOne(overrides);
+    }
+    return Array.from({ length: this.quantity }, () => this.makeOne(overrides));
+  }
+  async create(overrides = {}) {
+    if (!this.counted) {
+      return await this.createOne(overrides);
+    }
+    const records = [];
+    for (let index = 0;index < this.quantity; index += 1) {
+      records.push(await this.createOne(overrides));
+    }
+    return records;
+  }
+  makeOne(overrides = {}) {
+    let record = { ...this.definition() };
+    for (const state of this.stateTransforms) {
+      const patch = typeof state === "function" ? state(record) : state;
+      record = { ...record, ...patch };
+    }
+    if (this.sequenceItems.length > 0) {
+      const item = this.sequenceItems[this.sequenceIndex % this.sequenceItems.length];
+      const patch = typeof item === "function" ? item(this.sequenceIndex) : item;
+      record = { ...record, ...patch };
+      this.sequenceIndex += 1;
+    }
+    for (const association of this.parentAssociations) {
+      record[association.foreignKey] = association.value;
+    }
+    const made = {
+      ...record,
       ...overrides
     };
+    for (const callback of this.afterMakingCallbacks) {
+      callback(made);
+    }
+    return made;
   }
-  async create(overrides = {}) {
-    return this.persist(this.insertable(this.make(overrides)));
+  async createOne(overrides = {}) {
+    const created = await this.persist(this.insertable(this.makeOne(overrides)));
+    for (const child of this.children) {
+      await child.factory.for(created, child.foreignKey).create();
+    }
+    for (const callback of this.afterCreatingCallbacks) {
+      await callback(created);
+    }
+    return created;
   }
   insertable(record) {
     const values = { ...record };
@@ -21,7 +167,14 @@ class Factory {
     }
     return values;
   }
-  persist(_values) {
+  async persist(values) {
+    if (this.model) {
+      const created = await this.model.create(values);
+      if (created && typeof created.toObject === "function") {
+        return created.toObject();
+      }
+      return created;
+    }
     throw new Error("Factory.persist() must be implemented to use create().");
   }
 }