equipped 5.3.0 → 5.3.2

package/dist/cjs/orm/adapters/mongodb/index.cjs

@@ -586,148 +586,8 @@ ${settingsValidity.error.toString()}`, {
   }
 };
 
-// src/utilities/configurable.ts
-var import_valleyed3 = require("valleyed");
-function configurable(pipeFn, base) {
-  const pipe = pipeFn();
-  import_valleyed3.v.compile(pipe);
-  class Configurable extends base {
-    constructor(config, ...baseArgs) {
-      super(...baseArgs);
-      this.config = config;
-    }
-    static create(input, ...args) {
-      const r = import_valleyed3.v.validate(pipe, input);
-      if (!r.valid) throw r.error;
-      return new this(r.value, ...args);
-    }
-  }
-  return Configurable;
-}
-if (void 0) {
-  const { describe, test, expect, expectTypeOf } = void 0;
-  const { v: v6 } = null;
-  const testPipe = () => v6.object({
-    host: v6.string(),
-    port: v6.number()
-  });
-  class TestBase {
-    baseValue;
-    constructor() {
-      this.baseValue = "base";
-    }
-  }
-  class TestBaseWithArgs {
-    label;
-    constructor(label) {
-      this.label = label;
-    }
-  }
-  describe("configurable", () => {
-    test("validation runs in static create before constructor body executes", () => {
-      let constructorRan = false;
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-          constructorRan = true;
-        }
-      }
-      expect(() => MyClass.create({ host: 123, port: "bad" })).toThrow();
-      expect(constructorRan).toBe(false);
-      MyClass.create({ host: "localhost", port: 3e3 });
-      expect(constructorRan).toBe(true);
-    });
-    test("constructor receives validated value", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      let receivedConfig;
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-          receivedConfig = this.config;
-        }
-      }
-      MyClass.create({ host: "localhost", port: 3e3 });
-      expect(receivedConfig).toEqual({ host: "localhost", port: 3e3 });
-    });
-    test("external new is a compile error", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-      }
-      void (() => new MyClass({ host: "localhost", port: 3e3 }));
-    });
-    test("static Config resolves to PipeOutput<P> at the type level", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-      }
-      expectTypeOf().toEqualTypeOf();
-      expect(MyClass.create).toBeTypeOf("function");
-    });
-    test("ConstructorParameters<This>-based extras inference works for non-zero-arg leaf signatures", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        extra;
-        constructor(config, extra) {
-          super(config);
-          this.extra = extra;
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 }, 42);
-      expect(instance.extra).toBe(42);
-      expectTypeOf(instance).toHaveProperty("extra");
-      expectTypeOf(instance.extra).toEqualTypeOf();
-      void (() => MyClass.create({ host: "localhost", port: 3e3 }, "not-a-number"));
-    });
-    test("base-args forwarding works for non-zero-arg bases", () => {
-      const Wrapped = configurable(testPipe, TestBaseWithArgs);
-      class MyClass extends Wrapped {
-        constructor(config, label) {
-          super(config, label);
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 }, "test-label");
-      expect(instance.label).toBe("test-label");
-    });
-    test("config is accessible as protected readonly on instances", () => {
-      const Wrapped = configurable(testPipe, TestBase);
-      class MyClass extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-        getHost() {
-          return this.config.host;
-        }
-      }
-      const instance = MyClass.create({ host: "localhost", port: 3e3 });
-      expect(instance.getHost()).toBe("localhost");
-    });
-    test("accepts an abstract base class", () => {
-      class AbstractBase {
-      }
-      const Wrapped = configurable(testPipe, AbstractBase);
-      class Concrete extends Wrapped {
-        constructor(config) {
-          super(config);
-        }
-        greet() {
-          return `hello from ${this.config.host}`;
-        }
-      }
-      const instance = Concrete.create({ host: "localhost", port: 3e3 });
-      expect(instance.greet()).toBe("hello from localhost");
-      expectTypeOf(instance).toHaveProperty("config");
-    });
-  });
-}
-
 // src/orm/fields.ts
-var import_valleyed4 = require("valleyed");
+var import_valleyed3 = require("valleyed");
 var Field = class {
   name;
   path;
@@ -766,7 +626,7 @@ if (void 0) {
     });
     describe("SchemaField", () => {
       test("extends Field and stores pipe", () => {
-        const mockPipe = v4.string();
+        const mockPipe = v3.string();
         const f = new SchemaField("email", mockPipe);
         expect(f).toBeInstanceOf(Field);
         expect(f.name).toBe("email");
@@ -774,7 +634,7 @@ if (void 0) {
         expect(f.pipe).toBe(mockPipe);
       });
       test("stores lifecycle hooks when provided", () => {
-        const mockPipe = v4.number();
+        const mockPipe = v3.number();
         const f = new SchemaField("updatedAt", mockPipe, {
           onCreate: () => 1e3,
           onUpdate: () => 2e3
@@ -783,7 +643,7 @@ if (void 0) {
         expect(f.onUpdate?.()).toBe(2e3);
       });
       test("keeps lifecycle hooks undefined when omitted", () => {
-        const mockPipe = v4.string();
+        const mockPipe = v3.string();
         const f = new SchemaField("name", mockPipe);
         expect(f.onCreate).toBeUndefined();
         expect(f.onUpdate).toBeUndefined();
@@ -2018,6 +1878,146 @@ if (void 0) {
   });
 }
 
+// src/utilities/configurable.ts
+var import_valleyed4 = require("valleyed");
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  import_valleyed4.v.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = import_valleyed4.v.validate(pipe, input);
+      if (!r.valid) throw r.error;
+      return new this(r.value, ...args);
+    }
+  }
+  return Configurable;
+}
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  const { v: v6 } = null;
+  const testPipe = () => v6.object({
+    host: v6.string(),
+    port: v6.number()
+  });
+  class TestBase {
+    baseValue;
+    constructor() {
+      this.baseValue = "base";
+    }
+  }
+  class TestBaseWithArgs {
+    label;
+    constructor(label) {
+      this.label = label;
+    }
+  }
+  describe("configurable", () => {
+    test("validation runs in static create before constructor body executes", () => {
+      let constructorRan = false;
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+          constructorRan = true;
+        }
+      }
+      expect(() => MyClass.create({ host: 123, port: "bad" })).toThrow();
+      expect(constructorRan).toBe(false);
+      MyClass.create({ host: "localhost", port: 3e3 });
+      expect(constructorRan).toBe(true);
+    });
+    test("constructor receives validated value", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      let receivedConfig;
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+          receivedConfig = this.config;
+        }
+      }
+      MyClass.create({ host: "localhost", port: 3e3 });
+      expect(receivedConfig).toEqual({ host: "localhost", port: 3e3 });
+    });
+    test("external new is a compile error", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+      }
+      void (() => new MyClass({ host: "localhost", port: 3e3 }));
+    });
+    test("static Config resolves to PipeOutput<P> at the type level", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+      }
+      expectTypeOf().toEqualTypeOf();
+      expect(MyClass.create).toBeTypeOf("function");
+    });
+    test("ConstructorParameters<This>-based extras inference works for non-zero-arg leaf signatures", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        extra;
+        constructor(config, extra) {
+          super(config);
+          this.extra = extra;
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 }, 42);
+      expect(instance.extra).toBe(42);
+      expectTypeOf(instance).toHaveProperty("extra");
+      expectTypeOf(instance.extra).toEqualTypeOf();
+      void (() => MyClass.create({ host: "localhost", port: 3e3 }, "not-a-number"));
+    });
+    test("base-args forwarding works for non-zero-arg bases", () => {
+      const Wrapped = configurable(testPipe, TestBaseWithArgs);
+      class MyClass extends Wrapped {
+        constructor(config, label) {
+          super(config, label);
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 }, "test-label");
+      expect(instance.label).toBe("test-label");
+    });
+    test("config is accessible as protected readonly on instances", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+        getHost() {
+          return this.config.host;
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 });
+      expect(instance.getHost()).toBe("localhost");
+    });
+    test("accepts an abstract base class", () => {
+      class AbstractBase {
+      }
+      const Wrapped = configurable(testPipe, AbstractBase);
+      class Concrete extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+        greet() {
+          return `hello from ${this.config.host}`;
+        }
+      }
+      const instance = Concrete.create({ host: "localhost", port: 3e3 });
+      expect(instance.greet()).toBe("hello from localhost");
+      expectTypeOf(instance).toHaveProperty("config");
+    });
+  });
+}
+
 // src/orm/orm-adapter.ts
 var OrmAdapter = class {
   queryableOps = [];