orchid-orm-test-factory 0.7.66 → 1.0.2

package/dist/index.js

@@ -1,27 +1,12 @@
 'use strict';
 
-var zod = require('zod');
 var pqb = require('pqb');
-var zodMock = require('@anatine/zod-mock');
+var orchidCore = require('orchid-core');
+var faker = require('@faker-js/faker');
+var randexp = require('randexp');
 
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 const omit = (obj, keys) => {
-  const res = __spreadValues({}, obj);
+  const res = { ...obj };
   Object.keys(keys).forEach((key) => {
     delete res[key];
   });
@@ -37,83 +22,39 @@ const pick = (obj, keys) => {
   });
   return res;
 };
-const makeUniqueText = (sequence, value) => `${sequence} ${value}`;
-const makeUniqueEmail = (sequence, value) => `${sequence}-${value}`;
-const makeUniqueUrl = (sequence, value) => value.replace("://", `://${sequence}-`);
-const makeUniqueNumber = (sequence) => sequence;
-const makeSetUniqueValues = (uniqueFields, data) => {
-  var _a;
-  const dataKeys = Object.keys(data);
-  const fns = {};
-  for (const field of uniqueFields) {
-    if (dataKeys.includes(field.key))
-      continue;
-    if (field.type === "text") {
-      const getValue = field.kind === "email" ? makeUniqueEmail : field.kind === "url" ? makeUniqueUrl : makeUniqueText;
-      let fn;
-      const max = (_a = field.length) != null ? _a : field.max;
-      if (max !== void 0) {
-        fn = (sequence, value) => {
-          let result = getValue(sequence, value);
-          if (result.length > max) {
-            result = result.slice(0, -(result.length - max));
-          }
-          return result;
-        };
-      } else {
-        fn = getValue;
-      }
-      fns[field.key] = fn;
-    } else {
-      let fn;
-      const { gt, gte } = field;
-      if (gt) {
-        fn = (sequence) => sequence + gt;
-      } else if (gte) {
-        fn = (sequence) => sequence + gte - 1;
-      } else {
-        fn = makeUniqueNumber;
-      }
-      fns[field.key] = fn;
-    }
-  }
-  return (record, sequence) => {
-    for (const key in fns) {
-      record[key] = fns[key](sequence, record[key]);
-    }
-  };
-};
-const makeBuild = (factory, data, omitValues, pickValues, uniqueFields, arg) => {
-  let schema = factory.schema;
-  let allData = arg ? __spreadValues(__spreadValues({}, data), arg) : data;
+const makeBuild = (factory, data, omitValues, pickValues, arg) => {
+  let { fns } = factory;
+  let allData = arg ? { ...data, ...arg } : data;
   if (omitValues) {
-    schema = schema.omit(omitValues);
+    fns = omit(fns, omitValues);
     allData = omit(allData, omitValues);
   }
   if (pickValues && Object.keys(pickValues).length) {
-    schema = schema.pick(pickValues);
+    fns = pick(fns, pickValues);
     allData = pick(allData, pickValues);
   }
-  const setUniqueValues = makeSetUniqueValues(uniqueFields, allData);
   return (arg2) => {
-    const data2 = arg2 ? __spreadValues(__spreadValues({}, allData), arg2) : allData;
-    const result = zodMock.generateMock(schema);
+    const data2 = arg2 ? { ...allData, ...arg2 } : allData;
+    const sequence = factory.sequence++;
+    const result = {};
+    for (const key in fns) {
+      result[key] = fns[key](sequence);
+    }
     for (const key in data2) {
       const value = data2[key];
       if (typeof value === "function") {
-        result[key] = value(factory.sequence);
+        result[key] = value(sequence);
       } else {
         result[key] = value;
       }
     }
-    setUniqueValues(result, factory.sequence);
-    factory.sequence++;
     return result;
   };
 };
-const processCreateData = (factory, data, uniqueFields, arg) => {
+const processCreateData = (factory, data, arg) => {
+  const { fns } = factory;
   const pick2 = {};
-  for (const key in factory.table.shape) {
+  for (const key in fns) {
     pick2[key] = true;
   }
   for (const key of pqb.getPrimaryKeys(factory.table)) {
@@ -123,8 +64,7 @@ const processCreateData = (factory, data, uniqueFields, arg) => {
     }
   }
   const shared = {};
-  const fns = {};
-  const allData = arg ? __spreadValues(__spreadValues({}, data), arg) : data;
+  const allData = arg ? { ...data, ...arg } : data;
   for (const key in allData) {
     delete pick2[key];
     const value = allData[key];
@@ -134,12 +74,13 @@ const processCreateData = (factory, data, uniqueFields, arg) => {
       shared[key] = value;
     }
   }
-  const pickedSchema = factory.schema.pick(pick2);
-  const setUniqueValues = makeSetUniqueValues(uniqueFields, allData);
   return async (arg2) => {
-    const result = Object.assign(__spreadValues({}, shared), zodMock.generateMock(pickedSchema));
     const { sequence } = factory;
     factory.sequence++;
+    const result = { ...shared };
+    for (const key in pick2) {
+      result[key] = fns[key](sequence);
+    }
     if (arg2) {
       for (const key in arg2) {
         if (typeof arg2[key] === "function") {
@@ -151,6 +92,7 @@ const processCreateData = (factory, data, uniqueFields, arg) => {
     } else {
       const promises = [];
       for (const key in fns) {
+        if (key in result) continue;
         promises.push(
           new Promise(async (resolve, reject) => {
             try {
@@ -164,41 +106,37 @@ const processCreateData = (factory, data, uniqueFields, arg) => {
       }
       await Promise.all(promises);
     }
-    setUniqueValues(result, sequence);
     return result;
   };
 };
-const _TestFactory = class {
-  constructor(table, schema, uniqueFields, data = {}, options = {}) {
+const _TestFactory = class _TestFactory {
+  constructor(table, fns, options = {}) {
     this.table = table;
-    this.schema = schema;
-    this.uniqueFields = uniqueFields;
-    this.data = data;
+    this.fns = fns;
     this.omitValues = {};
     this.pickValues = {};
-    var _a;
+    this.data = {};
     if (options.sequence !== void 0) {
       this.sequence = options.sequence;
     } else {
       let workerId = parseInt(process.env.JEST_WORKER_ID);
-      if (isNaN(workerId))
-        workerId = 1;
-      this.sequence = (workerId - 1) * ((_a = options.sequenceDistance) != null ? _a : 1e3) + 1;
+      if (isNaN(workerId)) workerId = 1;
+      this.sequence = (workerId - 1) * (options.sequenceDistance ?? 1e3) + 1;
     }
   }
   set(data) {
     return Object.assign(Object.create(this), {
-      data: __spreadValues(__spreadValues({}, this.data), data)
+      data: { ...this.data, ...data }
     });
   }
   omit(keys) {
     return Object.assign(Object.create(this), {
-      omitValues: __spreadValues(__spreadValues({}, this.omitValues), keys)
+      omitValues: { ...this.omitValues, ...keys }
     });
   }
   pick(keys) {
     return Object.assign(Object.create(this), {
-      pickValues: __spreadValues(__spreadValues({}, this.pickValues), keys)
+      pickValues: { ...this.pickValues, ...keys }
     });
   }
   build(data) {
@@ -207,7 +145,6 @@ const _TestFactory = class {
       this.data,
       this.omitValues,
       this.pickValues,
-      this.uniqueFields,
       data
     );
     return build();
@@ -218,118 +155,426 @@ const _TestFactory = class {
       this.data,
       this.omitValues,
       this.pickValues,
-      this.uniqueFields,
       data
     );
-    return [...Array(qty)].map(build);
+    return Array.from({ length: qty }, () => build());
   }
-  buildMany(...arr) {
-    const build = makeBuild(
-      this,
-      this.data,
-      this.omitValues,
-      this.pickValues,
-      this.uniqueFields
-    );
-    return arr.map(build);
+  buildMany(...arr2) {
+    const build = makeBuild(this, this.data, this.omitValues, this.pickValues);
+    return arr2.map(build);
   }
   async create(data) {
-    const getData = processCreateData(this, this.data, this.uniqueFields, data);
-    return await this.table.create(await getData());
+    const getData = processCreateData(this, this.data, data);
+    return await this.table.create(
+      await getData()
+    );
   }
   async createList(qty, data) {
-    const getData = processCreateData(this, this.data, this.uniqueFields, data);
-    const arr = await Promise.all([...Array(qty)].map(() => getData()));
+    const getData = processCreateData(this, this.data, data);
+    const arr2 = await Promise.all([...Array(qty)].map(() => getData()));
     return await this.table.createMany(
-      arr
+      arr2
     );
   }
-  async createMany(...arr) {
-    const getData = processCreateData(this, this.data, this.uniqueFields);
-    const data = await Promise.all(arr.map(getData));
+  async createMany(...arr2) {
+    const getData = processCreateData(this, this.data);
+    const data = await Promise.all(arr2.map(getData));
     return await this.table.createMany(
       data
     );
   }
   extend() {
-    const { table, schema, uniqueFields } = this;
+    const { table, fns } = this;
     return class extends _TestFactory {
       constructor() {
-        super(table, schema, uniqueFields);
+        super(table, fns);
       }
     };
   }
 };
 let TestFactory = _TestFactory;
-const nowString = (/* @__PURE__ */ new Date()).toISOString();
-const maxPostgresInt = 2147483647;
-const tableFactory = (table, options) => {
-  var _a, _b, _c, _d;
-  const shape = {};
-  const columns = table.shape;
-  for (const key in columns) {
-    const { inputSchema } = columns[key];
-    if (inputSchema)
-      shape[key] = inputSchema;
+let fixedTime;
+let fixedTZ;
+const int = (min, max) => faker.faker.number.int({ min, max });
+const float = (min, max, multipleOf) => faker.faker.number.float({
+  min,
+  max,
+  multipleOf
+});
+const point = () => float(-100, 100, 0.01);
+const isoTime = (c, sequence) => {
+  const data = c.data;
+  return (data.min || data.max ? faker.faker.date.between({
+    from: data.min || /* @__PURE__ */ new Date(-864e13),
+    to: data.max || /* @__PURE__ */ new Date(864e13)
+  }) : new Date((fixedTime ?? (fixedTime = faker.faker.date.anytime())).getTime() + sequence)).toISOString();
+};
+const bool = () => faker.faker.datatype.boolean();
+const arr = (min, max, fn) => Array.from({ length: int(min, max) }, fn);
+const numOpts = (c, step, min, max, options) => ({
+  min: c.data.gt ? c.data.gt + (step || 0) : c.data.gte || min,
+  max: c.data.lt ? c.data.lt - (step || 0) : c.data.lte || max,
+  ...options
+});
+const num = (uniqueColumns, key, c, method, {
+  step,
+  min,
+  max,
+  module = "number",
+  ...options
+} = {}) => {
+  const opts = numOpts(c, step, min, max, options);
+  if (uniqueColumns.has(key)) {
+    if (method === "int" || method === "float" || method === "amount") {
+      const st = step || 1;
+      let min2 = (opts.min ?? 0) - st;
+      if (min2 < 0) min2 = 0;
+      const { symbol } = options;
+      if (symbol) {
+        return (sequence) => `${symbol}${min2 + sequence * st}`;
+      } else {
+        return (sequence) => min2 + sequence * st;
+      }
+    }
+    if (method === "bigInt") {
+      const st = step || 1n;
+      let min2 = (opts.min ?? 0n) - st;
+      if (min2 < 0n) min2 = 0n;
+      return (sequence) => min2 + BigInt(sequence) * st;
+    }
   }
-  const schema = zod.z.object(shape);
-  const data = {};
-  const now = Date.now();
-  const uniqueFields = [];
-  for (const key in table.shape) {
-    const column = table.shape[key];
-    if (column instanceof pqb.DateBaseColumn) {
-      if (column.data.as instanceof pqb.IntegerBaseColumn) {
-        data[key] = (sequence) => now + sequence;
-      } else if (((_b = (_a = column.data).parse) == null ? void 0 : _b.call(_a, nowString)) instanceof Date) {
-        data[key] = (sequence) => new Date(now + sequence);
+  return () => faker.faker[module][method](opts);
+};
+const makeGeneratorForColumn = (config, table, uniqueColumns, key, c) => {
+  let fn;
+  const custom = config.fakeDataForTypes?.[c.dataType]?.(c);
+  if (custom) {
+    fn = custom;
+  } else if (c instanceof pqb.EnumColumn) {
+    fn = () => faker.faker.helpers.arrayElement(c.options);
+  } else if (c instanceof pqb.ArrayColumn) {
+    fn = () => arr(
+      1,
+      5,
+      makeGeneratorForColumn(
+        config,
+        table,
+        uniqueColumns,
+        key,
+        c.data.item
+      )
+    );
+  } else if (c instanceof pqb.SmallIntColumn || c instanceof pqb.SmallSerialColumn) {
+    fn = num(uniqueColumns, key, c, "int", {
+      step: 1,
+      min: -32768,
+      max: 32767
+    });
+  } else if (c instanceof pqb.IntegerColumn || c instanceof pqb.SerialColumn) {
+    fn = num(uniqueColumns, key, c, "int", {
+      step: 1,
+      min: -2147483648,
+      max: 2147483648
+    });
+  } else if (c instanceof pqb.BigIntColumn || c instanceof pqb.BigSerialColumn) {
+    fn = num(uniqueColumns, key, c, "bigInt", {
+      step: 1n,
+      min: BigInt("-9223372036854775808"),
+      max: BigInt("9223372036854775807")
+    });
+  } else if (c instanceof pqb.DecimalColumn || c instanceof pqb.DoublePrecisionColumn) {
+    fn = num(uniqueColumns, key, c, "float", {
+      fractionDigits: c.data.numericScale
+    });
+  } else if (c instanceof pqb.RealColumn) {
+    fn = num(uniqueColumns, key, c, "float");
+  } else if (c instanceof pqb.MoneyColumn) {
+    fn = num(uniqueColumns, key, c, "amount", {
+      module: "finance",
+      symbol: "$"
+    });
+  } else if (c instanceof pqb.VarCharColumn || c instanceof pqb.TextColumn || c instanceof pqb.StringColumn || c instanceof pqb.CitextColumn) {
+    const data = c.data;
+    const lowerKey = key.toLowerCase();
+    const strippedKey = lowerKey.replace(/_|-/g, "");
+    let gen;
+    const min = data.length ?? data.min ?? data.nonEmpty ? 1 : 0;
+    const max = Math.min(
+      data.length ?? data.max ?? Infinity,
+      config.maxTextLength ?? 1e3
+    );
+    const { includes, startsWith, endsWith, trim, toLowerCase, toUpperCase } = data;
+    let isEmail = false;
+    let isUrl = false;
+    if (data.email) {
+      isEmail = true;
+      gen = () => faker.faker.internet.email();
+    } else if (data.emoji) {
+      gen = () => faker.faker.internet.emoji();
+    } else if (data.url) {
+      isUrl = true;
+      gen = () => faker.faker.internet.url();
+    } else if (data.uuid) {
+      gen = () => faker.faker.string.uuid();
+    } else if (data.datetime) {
+      gen = (sequence) => isoTime(c, sequence);
+    } else if (data.ip) {
+      if (data.ip.version === "v4") {
+        gen = () => faker.faker.internet.ipv4();
+      } else if (data.ip.version === "v6") {
+        gen = () => faker.faker.internet.ipv6();
       } else {
-        data[key] = (sequence) => new Date(now + sequence).toISOString();
+        gen = () => faker.faker.internet.ip();
       }
-    } else if (column instanceof pqb.TextBaseColumn) {
-      const max = (_c = options == null ? void 0 : options.maxTextLength) != null ? _c : 1e3;
-      const item = schema.shape[key];
-      const string = item instanceof zod.ZodNullable ? item.unwrap() : item;
-      const maxCheck = string._def.checks.find(
-        (check) => check.kind === "max"
-      );
-      if (!maxCheck || maxCheck.value > max) {
-        schema.shape[key] = item instanceof zod.ZodNullable ? string.max(max).nullable() : string.max(max);
+    } else if (data.regex) {
+      const generator = new randexp(data.regex);
+      generator.randInt = (min2, max2) => faker.faker.number.int({ min: min2, max: max2 });
+      if (max !== Infinity) {
+        generator.max = max;
       }
-    } else if (column instanceof pqb.IntegerBaseColumn) {
-      const item = schema.shape[key];
-      const num = item instanceof zod.ZodNullable ? item.unwrap() : item;
-      const maxCheck = num._def.checks.find((check) => check.kind === "max");
-      if (!maxCheck) {
-        schema.shape[key] = item instanceof zod.ZodNullable ? num.max(maxPostgresInt).nullable() : num.max(maxPostgresInt);
+      gen = () => generator.gen();
+    } else if (strippedKey === "name") {
+      gen = () => faker.faker.person.fullName();
+    } else if (strippedKey === "phonenumber") {
+      gen = () => faker.faker.phone.number();
+    } else if (strippedKey === "image" || strippedKey === "imageurl") {
+      gen = () => faker.faker.image.url();
+    } else {
+      for (const sectionKey in faker.faker) {
+        for (const key2 in faker.faker[sectionKey]) {
+          if (key2 === strippedKey) {
+            const fn2 = faker.faker[sectionKey][key2];
+            gen = () => String(fn2());
+            if (key2 === "email") isEmail = true;
+            else if (key2 === "url") isUrl = true;
+          }
+        }
       }
+      if (!gen) gen = () => faker.faker.food.dish();
     }
-    if ((_d = column.data.indexes) == null ? void 0 : _d.some((index) => index.options.unique)) {
-      if (column instanceof pqb.TextBaseColumn) {
-        uniqueFields.push({
-          key,
-          type: "text",
-          kind: column.data.email ? "email" : column.data.url ? "url" : void 0,
-          max: column.data.max,
-          length: column.data.length
-        });
-      } else if (column instanceof pqb.NumberBaseColumn) {
-        uniqueFields.push({
-          key,
-          type: "number",
-          gt: column.data.gt,
-          gte: column.data.gte
-        });
+    const isUnique = uniqueColumns.has(key);
+    fn = (sequence) => {
+      const seq = sequence++;
+      let s = gen(seq);
+      if (isUnique) {
+        if (isEmail) s = `${seq}-${s}`;
+        else if (isUrl) s = s.replace("://", `://${seq}-`);
+        else s = `${seq} ${s}`;
+      }
+      while (s.length < min) {
+        s += gen(seq);
+        if (trim) s = s.trim();
+      }
+      if (s.length > max) {
+        s = s.slice(0, max);
+        if (trim) {
+          s = s.trim();
+          while (s.length < min) {
+            s += gen(seq);
+            if (trim) s = s.trim();
+          }
+        }
+      }
+      if (startsWith) {
+        s = startsWith + s.slice(startsWith.length);
+      }
+      if (includes) {
+        const start = Math.max(
+          0,
+          Math.floor(s.length / 2) - Math.floor(includes.length / 2)
+        );
+        s = s.slice(0, start) + includes + s.slice(start + includes.length);
+      }
+      if (endsWith) {
+        s = s.slice(0, endsWith.length + 1) + endsWith;
+      }
+      return toLowerCase ? s.toLocaleLowerCase() : toUpperCase ? s.toLocaleUpperCase() : s;
+    };
+  } else if (c instanceof pqb.ByteaColumn) {
+    fn = () => Buffer.from(arr(1, 10, () => int(0, 255)));
+  } else if (c instanceof pqb.DateColumn) {
+    fn = (sequence) => isoTime(c, sequence).split("T")[0];
+  } else if (c instanceof pqb.TimestampColumn || c instanceof pqb.TimestampTZColumn) {
+    const hasTZ = c instanceof pqb.TimestampTZColumn;
+    fn = (sequence) => {
+      let timestamp = isoTime(c, sequence).replace("T", " ");
+      if (hasTZ) {
+        if (!fixedTZ) {
+          const minOffset = -720;
+          const maxOffset = 840;
+          const randomOffset = int(minOffset, maxOffset);
+          const sign = randomOffset >= 0 ? "+" : "-";
+          const absOffset = Math.abs(randomOffset);
+          const hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
+          const minutes = String(absOffset % 60).padStart(2, "0");
+          fixedTZ = `${sign}${hours}:${minutes}`;
+        }
+        timestamp += fixedTZ;
       }
+      return timestamp;
+    };
+  } else if (c instanceof pqb.TimeColumn) {
+    fn = (sequence) => isoTime(c, sequence).split("T")[1].replace(/\..+/, "");
+  } else if (c instanceof pqb.IntervalColumn) {
+    fn = () => {
+      const years = int(0, 10);
+      const months = int(0, 11);
+      const days = int(0, 30);
+      const hours = int(0, 23);
+      const minutes = int(0, 59);
+      const seconds = float(0, 59, 0.1);
+      return `${years} years ${months} mons ${days} days ${hours} hours ${minutes} mins ${seconds.toFixed(
+        1
+      )} secs`;
+    };
+  } else if (c instanceof pqb.BooleanColumn) {
+    fn = bool;
+  } else if (c instanceof pqb.PointColumn) {
+    fn = () => `(${point()}, ${point()})`;
+  } else if (c instanceof pqb.LineColumn) {
+    fn = () => `{${point()},${point()},${point()}}`;
+  } else if (c instanceof pqb.LsegColumn) {
+    fn = () => `((${point()}, ${point()}), (${point()}, ${point()}))`;
+  } else if (c instanceof pqb.BoxColumn) {
+    fn = () => `((${point()}, ${point()}), (${point()}, ${point()}))`;
+  } else if (c instanceof pqb.PathColumn) {
+    fn = () => {
+      const s = arr(2, 10, () => `(${point()}, ${point()})`).join(", ");
+      return bool() ? `[${s}]` : `(${s})`;
+    };
+  } else if (c instanceof pqb.PolygonColumn) {
+    fn = () => `(${arr(2, 10, () => `(${point()}, ${point()})`).join(", ")})`;
+  } else if (c instanceof pqb.CircleColumn) {
+    fn = () => `<(${point()}, ${point()}), ${float(0, 100, 0.01)}>`;
+  } else if (c instanceof pqb.CidrColumn) {
+    fn = () => `${faker.faker.internet.ip()}/${int(0, 32)}`;
+  } else if (c instanceof pqb.InetColumn) {
+    fn = () => bool() ? faker.faker.internet.ip() : faker.faker.internet.ipv6();
+  } else if (c instanceof pqb.MacAddrColumn) {
+    fn = () => faker.faker.internet.mac();
+  } else if (c instanceof pqb.MacAddr8Column) {
+    fn = () => Array.from(
+      { length: 8 },
+      () => faker.faker.string.hexadecimal({ length: 2 })
+    ).join(":");
+  } else if (c instanceof pqb.BitColumn) {
+    const { length } = c.data;
+    fn = () => Array.from({ length }, () => bool() ? "1" : "0").join("");
+  } else if (c instanceof pqb.BitVaryingColumn) {
+    const length = c.data.length;
+    fn = () => arr(1, length || 100, () => bool() ? "1" : "0").join("");
+  } else if (c instanceof pqb.TsVectorColumn) {
+    fn = () => arr(1, 10, () => faker.faker.lorem.word()).join(" ");
+  } else if (c instanceof pqb.TsQueryColumn) {
+    fn = () => {
+      const operators = ["&", "|", "<->"];
+      return arr(1, 10, (_, i) => {
+        const word = faker.faker.lorem.word();
+        return i === 0 ? word : faker.faker.helpers.arrayElement(operators) + " " + word;
+      }).join(" ");
+    };
+  } else if (c instanceof pqb.UUIDColumn) {
+    fn = () => faker.faker.string.uuid();
+  } else if (c instanceof pqb.XMLColumn) {
+    fn = () => "<items>\n" + arr(
+      1,
+      5,
+      () => `  <item>
+    <id>${faker.faker.string.uuid()}</id>
+    <name>${faker.faker.person.firstName()}</name>
+    <email>${faker.faker.internet.email()}</email>
+    <address>${faker.faker.location.streetAddress()}</address>
+    <created_at>${faker.faker.date.past().toISOString()}</created_at>
+  </item>
+`
+    ).join("") + "</items>";
+  } else if (c instanceof pqb.JSONColumn || c instanceof pqb.JSONTextColumn) {
+    fn = () => JSON.stringify(
+      arr(1, 5, () => ({
+        id: faker.faker.string.uuid(),
+        name: faker.faker.person.firstName(),
+        email: faker.faker.internet.email(),
+        address: {
+          street: faker.faker.location.streetAddress(),
+          city: faker.faker.location.city(),
+          state: faker.faker.location.state(),
+          zip: faker.faker.location.zipCode()
+        },
+        createdAt: faker.faker.date.past().toISOString()
+      }))
+    );
+  } else if (c instanceof pqb.VirtualColumn) {
+    return;
+  } else if (c instanceof pqb.PostgisGeographyPointColumn) {
+    fn = () => {
+      const lon = faker.faker.location.longitude({ min: -180, max: 180 });
+      const lat = faker.faker.location.latitude({ min: -90, max: 90 });
+      return pqb.PostgisGeographyPointColumn.encode({ lon, lat });
+    };
+  } else {
+    const as = c.data.as;
+    if (!as) {
+      throw new Error(
+        `Don't know how to generate data for column ${table.table}.${key} that has no \`as\``
+      );
     }
+    return makeGeneratorForColumn(config, table, uniqueColumns, key, as);
   }
-  return new TestFactory(
-    table,
-    schema,
-    uniqueFields,
-    data,
-    options
-  );
+  return fn;
+};
+const tableFactory = (table, config) => {
+  const { shape } = table;
+  const fns = {
+    ...config?.extend
+  };
+  const uniqueColumns = /* @__PURE__ */ new Set();
+  for (const key in shape) {
+    if (fns[key]) continue;
+    const {
+      data: { indexes: indexes2, primaryKey: primaryKey2 }
+    } = shape[key];
+    if (primaryKey2) {
+      uniqueColumns.add(key);
+      continue;
+    }
+    if (!indexes2) continue;
+    for (const index of indexes2) {
+      if (index.options.unique) {
+        uniqueColumns.add(key);
+        break;
+      }
+    }
+  }
+  const { primaryKey, indexes } = table.internal.tableData;
+  if (primaryKey) {
+    for (const key of primaryKey.columns) {
+      if (fns[key]) continue;
+      uniqueColumns.add(key);
+    }
+  }
+  if (indexes) {
+    for (const index of indexes) {
+      if (index.options.unique) {
+        for (const item of index.columns) {
+          if ("column" in item) {
+            uniqueColumns.add(item.column);
+          }
+        }
+      }
+    }
+  }
+  for (const key in shape) {
+    if (fns[key]) continue;
+    const fn = makeGeneratorForColumn(
+      config || orchidCore.emptyObject,
+      table,
+      uniqueColumns,
+      key,
+      shape[key]
+    );
+    if (fn) fns[key] = fn;
+  }
+  return new TestFactory(table, fns, config);
 };
 const ormFactory = (orm, options) => {
   const factory = {};
@@ -339,11 +584,13 @@ const ormFactory = (orm, options) => {
     if (table && typeof table === "object" && "definedAs" in table) {
       Object.defineProperty(factory, key, {
         get() {
-          var _a;
-          return (_a = defined[key]) != null ? _a : defined[key] = tableFactory(
+          return defined[key] ?? (defined[key] = tableFactory(
             table,
-            options
-          );
+            {
+              ...options,
+              extend: options?.extend?.[key]
+            }
+          ));
         }
       });
     }