equipped 5.3.0 → 5.3.2

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

@@ -610,216 +610,6 @@ ${settingsValidity.error.toString()}`, {
   }
 });
 
-// src/utilities/authProviders.ts
-var import_axios, import_jsonwebtoken, import_jwks_rsa;
-var init_authProviders = __esm({
-  "src/utilities/authProviders.ts"() {
-    "use strict";
-    import_axios = __toESM(require("axios"), 1);
-    import_jsonwebtoken = __toESM(require("jsonwebtoken"), 1);
-    import_jwks_rsa = __toESM(require("jwks-rsa"), 1);
-  }
-});
-
-// src/utilities/configurable.ts
-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;
-}
-var import_valleyed3;
-var init_configurable = __esm({
-  "src/utilities/configurable.ts"() {
-    "use strict";
-    import_valleyed3 = require("valleyed");
-    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/utilities/hash.ts
-var bcrypt;
-var init_hash = __esm({
-  "src/utilities/hash.ts"() {
-    "use strict";
-    bcrypt = __toESM(require("bcryptjs"), 1);
-  }
-});
-
-// src/utilities/json.ts
-var init_json = __esm({
-  "src/utilities/json.ts"() {
-    "use strict";
-  }
-});
-
-// src/utilities/media.ts
-var import_music_metadata;
-var init_media = __esm({
-  "src/utilities/media.ts"() {
-    "use strict";
-    import_music_metadata = require("music-metadata");
-  }
-});
-
-// src/utilities/random.ts
-var init_random = __esm({
-  "src/utilities/random.ts"() {
-    "use strict";
-  }
-});
-
-// src/utilities/retry.ts
-var init_retry = __esm({
-  "src/utilities/retry.ts"() {
-    "use strict";
-  }
-});
-
-// src/utilities/index.ts
-var init_utilities = __esm({
-  "src/utilities/index.ts"() {
-    "use strict";
-    init_authProviders();
-    init_configurable();
-    init_hash();
-    init_json();
-    init_media();
-    init_random();
-    init_retry();
-  }
-});
-
 // src/errors/types/badRequestError.ts
 var init_badRequestError = __esm({
   "src/errors/types/badRequestError.ts"() {
@@ -948,7 +738,7 @@ var import_valleyed5 = require("valleyed");
 init_errors();
 
 // src/orm/fields.ts
-var import_valleyed4 = require("valleyed");
+var import_valleyed3 = require("valleyed");
 var Field = class {
   name;
   path;
@@ -987,7 +777,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");
@@ -995,7 +785,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
@@ -1004,7 +794,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();
@@ -2466,7 +2256,146 @@ if (void 0) {
 
 // src/orm/adapters/postgresql/index.ts
 init_errors();
-init_utilities();
+
+// 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
 init_errors();