@prisma-next/utils 0.3.0-dev.4 → 0.3.0-dev.5

package/dist/array-equal.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if two arrays are equal using Object.is() for element comparison.
+ * Arrays are considered equal if they have the same length and each element
+ * at corresponding indices is equal according to Object.is().
+ *
+ * @param a - First array to compare
+ * @param b - Second array to compare
+ * @returns true if arrays are equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isArrayEqual(['a', 'b'], ['a', 'b']); // true
+ * isArrayEqual(['a'], ['a', 'b']); // false
+ * isArrayEqual([0], [-0]); // false (Object.is distinguishes +0 and -0)
+ * ```
+ */
+export declare function isArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean;
+//# sourceMappingURL=array-equal.d.ts.map

package/dist/array-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-equal.d.ts","sourceRoot":"","sources":["../src/array-equal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,GAAG,OAAO,CAUzE"}

package/dist/defined.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Returns an object with the key/value if value is defined, otherwise an empty object.
+ *
+ * Use with spread to conditionally include optional properties while satisfying
+ * exactOptionalPropertyTypes. This is explicit about which properties are optional
+ * and won't inadvertently strip other undefined values.
+ *
+ * @example
+ * ```typescript
+ * // Instead of:
+ * const obj = {
+ *   required: 'value',
+ *   ...(optional ? { optional } : {}),
+ * };
+ *
+ * // Use:
+ * const obj = {
+ *   required: 'value',
+ *   ...ifDefined('optional', optional),
+ * };
+ * ```
+ */
+export declare function ifDefined<K extends string, V>(key: K, value: V | undefined): Record<never, never> | {
+    [P in K]: V;
+};
+//# sourceMappingURL=defined.d.ts.map

package/dist/defined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defined.d.ts","sourceRoot":"","sources":["../src/defined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAC3C,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,GAAG,SAAS,GACnB,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,GAAG,CAAC;CAAE,CAExC"}

package/dist/exports/array-equal.d.ts

@@ -1,19 +1,2 @@
-/**
- * Checks if two arrays are equal using Object.is() for element comparison.
- * Arrays are considered equal if they have the same length and each element
- * at corresponding indices is equal according to Object.is().
- *
- * @param a - First array to compare
- * @param b - Second array to compare
- * @returns true if arrays are equal, false otherwise
- *
- * @example
- * ```typescript
- * isArrayEqual(['a', 'b'], ['a', 'b']); // true
- * isArrayEqual(['a'], ['a', 'b']); // false
- * isArrayEqual([0], [-0]); // false (Object.is distinguishes +0 and -0)
- * ```
- */
-declare function isArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean;
-
-export { isArrayEqual };
+export { isArrayEqual } from '../array-equal';
+//# sourceMappingURL=array-equal.d.ts.map

package/dist/exports/array-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-equal.d.ts","sourceRoot":"","sources":["../../src/exports/array-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/exports/defined.d.ts

@@ -1,27 +1,2 @@
-/**
- * Returns an object with the key/value if value is defined, otherwise an empty object.
- *
- * Use with spread to conditionally include optional properties while satisfying
- * exactOptionalPropertyTypes. This is explicit about which properties are optional
- * and won't inadvertently strip other undefined values.
- *
- * @example
- * ```typescript
- * // Instead of:
- * const obj = {
- *   required: 'value',
- *   ...(optional ? { optional } : {}),
- * };
- *
- * // Use:
- * const obj = {
- *   required: 'value',
- *   ...ifDefined('optional', optional),
- * };
- * ```
- */
-declare function ifDefined<K extends string, V>(key: K, value: V | undefined): Record<never, never> | {
-    [P in K]: V;
-};
-
-export { ifDefined };
+export { ifDefined } from '../defined';
+//# sourceMappingURL=defined.d.ts.map

package/dist/exports/defined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defined.d.ts","sourceRoot":"","sources":["../../src/exports/defined.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/dist/exports/redact-db-url.d.ts

@@ -1,19 +1,3 @@
-/**
- * Minimal metadata extracted from a database URL for logging or error output.
- * Sensitive fields (password, full URL) are never returned.
- */
-interface RedactedDatabaseUrl {
-    readonly host?: string;
-    readonly port?: string;
-    readonly database?: string;
-    readonly username?: string;
-}
-/**
- * Redacts a database connection URL to a minimal metadata object.
- *
- * Parsing errors are ignored and result in an empty object so callers never
- * leak raw URLs when the input is malformed.
- */
-declare function redactDatabaseUrl(url: string): RedactedDatabaseUrl;
-
-export { type RedactedDatabaseUrl, redactDatabaseUrl };
+export type { RedactedDatabaseUrl } from '../redact-db-url';
+export { redactDatabaseUrl } from '../redact-db-url';
+//# sourceMappingURL=redact-db-url.d.ts.map

package/dist/exports/redact-db-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact-db-url.d.ts","sourceRoot":"","sources":["../../src/exports/redact-db-url.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/exports/result.d.ts

@@ -1,51 +1,3 @@
-/**
- * Generic Result type for representing success or failure outcomes.
- *
- * This is the standard way to return "expected failures" as values rather than
- * throwing exceptions. See docs/Error Handling.md for the full taxonomy.
- *
- * Naming rationale:
- * - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator
- * - `NotOk` avoids collision with domain types like "Failure" or "Error"
- * - `failure` property distinguishes from JS Error semantics
- */
-/**
- * Represents a successful result containing a value.
- */
-interface Ok<T> {
-    readonly ok: true;
-    readonly value: T;
-    assertOk(): T;
-    assertNotOk(): never;
-}
-/**
- * Represents an unsuccessful result containing failure details.
- */
-interface NotOk<F> {
-    readonly ok: false;
-    readonly failure: F;
-    assertOk(): never;
-    assertNotOk(): F;
-}
-/**
- * A discriminated union representing either success (Ok) or failure (NotOk).
- *
- * @typeParam T - The success value type
- * @typeParam F - The failure details type
- */
-type Result<T, F> = Ok<T> | NotOk<F>;
-/**
- * Creates a successful result.
- */
-declare function ok<T>(value: T): Ok<T>;
-/**
- * Creates an unsuccessful result.
- */
-declare function notOk<F>(failure: F): NotOk<F>;
-/**
- * Returns a successful void result.
- * Use this for validation checks that don't produce a value.
- */
-declare function okVoid(): Ok<void>;
-
-export { type NotOk, type Ok, type Result, notOk, ok, okVoid };
+export type { NotOk, Ok, Result } from '../result';
+export { notOk, ok, okVoid } from '../result';
+//# sourceMappingURL=result.d.ts.map

package/dist/exports/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/exports/result.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC"}

package/dist/redact-db-url.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Minimal metadata extracted from a database URL for logging or error output.
+ * Sensitive fields (password, full URL) are never returned.
+ */
+export interface RedactedDatabaseUrl {
+    readonly host?: string;
+    readonly port?: string;
+    readonly database?: string;
+    readonly username?: string;
+}
+/**
+ * Redacts a database connection URL to a minimal metadata object.
+ *
+ * Parsing errors are ignored and result in an empty object so callers never
+ * leak raw URLs when the input is malformed.
+ */
+export declare function redactDatabaseUrl(url: string): RedactedDatabaseUrl;
+//# sourceMappingURL=redact-db-url.d.ts.map

package/dist/redact-db-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact-db-url.d.ts","sourceRoot":"","sources":["../src/redact-db-url.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAclE"}

package/dist/result.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Generic Result type for representing success or failure outcomes.
+ *
+ * This is the standard way to return "expected failures" as values rather than
+ * throwing exceptions. See docs/Error Handling.md for the full taxonomy.
+ *
+ * Naming rationale:
+ * - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator
+ * - `NotOk` avoids collision with domain types like "Failure" or "Error"
+ * - `failure` property distinguishes from JS Error semantics
+ */
+/**
+ * Represents a successful result containing a value.
+ */
+export interface Ok<T> {
+    readonly ok: true;
+    readonly value: T;
+    assertOk(): T;
+    assertNotOk(): never;
+}
+/**
+ * Represents an unsuccessful result containing failure details.
+ */
+export interface NotOk<F> {
+    readonly ok: false;
+    readonly failure: F;
+    assertOk(): never;
+    assertNotOk(): F;
+}
+/**
+ * A discriminated union representing either success (Ok) or failure (NotOk).
+ *
+ * @typeParam T - The success value type
+ * @typeParam F - The failure details type
+ */
+export type Result<T, F> = Ok<T> | NotOk<F>;
+/**
+ * Creates a successful result.
+ */
+export declare function ok<T>(value: T): Ok<T>;
+/**
+ * Creates an unsuccessful result.
+ */
+export declare function notOk<F>(failure: F): NotOk<F>;
+/**
+ * Returns a successful void result.
+ * Use this for validation checks that don't produce a value.
+ */
+export declare function okVoid(): Ok<void>;
+//# sourceMappingURL=result.d.ts.map

package/dist/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,MAAM,WAAW,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,IAAI,CAAC,CAAC;IACd,WAAW,IAAI,KAAK,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,IAAI,KAAK,CAAC;IAClB,WAAW,IAAI,CAAC,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AA6E5C;;GAEG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAErC;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAE7C;AAQD;;;GAGG;AACH,wBAAgB,MAAM,IAAI,EAAE,CAAC,IAAI,CAAC,CAEjC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/utils",
-  "version": "0.3.0-dev.4",
+  "version": "0.3.0-dev.5",
   "type": "module",
   "sideEffects": false,
   "description": "Shared utility functions for Prisma Next",
@@ -11,7 +11,8 @@
     "vitest": "4.0.16"
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "exports": {
     "./array-equal": {
@@ -32,7 +33,7 @@
     }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --project tsconfig.json --noEmit",

package/src/array-equal.ts

@@ -0,0 +1,27 @@
+/**
+ * Checks if two arrays are equal using Object.is() for element comparison.
+ * Arrays are considered equal if they have the same length and each element
+ * at corresponding indices is equal according to Object.is().
+ *
+ * @param a - First array to compare
+ * @param b - Second array to compare
+ * @returns true if arrays are equal, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isArrayEqual(['a', 'b'], ['a', 'b']); // true
+ * isArrayEqual(['a'], ['a', 'b']); // false
+ * isArrayEqual([0], [-0]); // false (Object.is distinguishes +0 and -0)
+ * ```
+ */
+export function isArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean {
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (!Object.is(a[i], b[i])) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/defined.ts

@@ -0,0 +1,28 @@
+/**
+ * Returns an object with the key/value if value is defined, otherwise an empty object.
+ *
+ * Use with spread to conditionally include optional properties while satisfying
+ * exactOptionalPropertyTypes. This is explicit about which properties are optional
+ * and won't inadvertently strip other undefined values.
+ *
+ * @example
+ * ```typescript
+ * // Instead of:
+ * const obj = {
+ *   required: 'value',
+ *   ...(optional ? { optional } : {}),
+ * };
+ *
+ * // Use:
+ * const obj = {
+ *   required: 'value',
+ *   ...ifDefined('optional', optional),
+ * };
+ * ```
+ */
+export function ifDefined<K extends string, V>(
+  key: K,
+  value: V | undefined,
+): Record<never, never> | { [P in K]: V } {
+  return value !== undefined ? ({ [key]: value } as { [P in K]: V }) : {};
+}

package/src/exports/array-equal.ts

@@ -0,0 +1 @@
+export { isArrayEqual } from '../array-equal';

package/src/exports/defined.ts

@@ -0,0 +1 @@
+export { ifDefined } from '../defined';

package/src/exports/redact-db-url.ts

@@ -0,0 +1,2 @@
+export type { RedactedDatabaseUrl } from '../redact-db-url';
+export { redactDatabaseUrl } from '../redact-db-url';

package/src/exports/result.ts

@@ -0,0 +1,2 @@
+export type { NotOk, Ok, Result } from '../result';
+export { notOk, ok, okVoid } from '../result';

package/src/redact-db-url.ts

@@ -0,0 +1,34 @@
+import { ifDefined } from './defined';
+
+/**
+ * Minimal metadata extracted from a database URL for logging or error output.
+ * Sensitive fields (password, full URL) are never returned.
+ */
+export interface RedactedDatabaseUrl {
+  readonly host?: string;
+  readonly port?: string;
+  readonly database?: string;
+  readonly username?: string;
+}
+
+/**
+ * Redacts a database connection URL to a minimal metadata object.
+ *
+ * Parsing errors are ignored and result in an empty object so callers never
+ * leak raw URLs when the input is malformed.
+ */
+export function redactDatabaseUrl(url: string): RedactedDatabaseUrl {
+  try {
+    const parsed = new URL(url);
+    const database = parsed.pathname?.replace(/^\//, '') || undefined;
+    return {
+      ...ifDefined('host', parsed.hostname || undefined),
+      ...ifDefined('port', parsed.port || undefined),
+      ...ifDefined('database', database),
+      ...ifDefined('username', parsed.username || undefined),
+    };
+  } catch {
+    // Ignore parsing errors; return empty metadata
+    return {};
+  }
+}

package/src/result.ts

@@ -0,0 +1,142 @@
+/**
+ * Generic Result type for representing success or failure outcomes.
+ *
+ * This is the standard way to return "expected failures" as values rather than
+ * throwing exceptions. See docs/Error Handling.md for the full taxonomy.
+ *
+ * Naming rationale:
+ * - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator
+ * - `NotOk` avoids collision with domain types like "Failure" or "Error"
+ * - `failure` property distinguishes from JS Error semantics
+ */
+
+/**
+ * Represents a successful result containing a value.
+ */
+export interface Ok<T> {
+  readonly ok: true;
+  readonly value: T;
+  assertOk(): T;
+  assertNotOk(): never;
+}
+
+/**
+ * Represents an unsuccessful result containing failure details.
+ */
+export interface NotOk<F> {
+  readonly ok: false;
+  readonly failure: F;
+  assertOk(): never;
+  assertNotOk(): F;
+}
+
+/**
+ * A discriminated union representing either success (Ok) or failure (NotOk).
+ *
+ * @typeParam T - The success value type
+ * @typeParam F - The failure details type
+ */
+export type Result<T, F> = Ok<T> | NotOk<F>;
+
+/**
+ * Result class that implements both Ok and NotOk variants.
+ */
+class ResultImpl<T, F> {
+  readonly ok: boolean;
+  private readonly _value?: T;
+  private readonly _failure?: F;
+
+  private constructor(ok: boolean, valueOrFailure: T | F) {
+    this.ok = ok;
+    if (ok) {
+      this._value = valueOrFailure as T;
+    } else {
+      this._failure = valueOrFailure as F;
+    }
+    Object.freeze(this);
+  }
+
+  get value(): T {
+    if (!this.ok) {
+      throw new Error('Cannot access value on NotOk result');
+    }
+    // biome-ignore lint/style/noNonNullAssertion: must be present if ok is true
+    return this._value!;
+  }
+
+  get failure(): F {
+    if (this.ok) {
+      throw new Error('Cannot access failure on Ok result');
+    }
+    // biome-ignore lint/style/noNonNullAssertion: must be present if ok is false
+    return this._failure!;
+  }
+
+  /**
+   * Creates a successful result.
+   */
+  static ok<T, F = never>(value: T): Ok<T> {
+    // TypeScript cannot express discriminated return types for a single implementation.
+    // Cast is safe: ok=true guarantees this is an Ok<T> at runtime.
+    return new ResultImpl<T, F>(true, value) as unknown as Ok<T>;
+  }
+
+  /**
+   * Creates an unsuccessful result.
+   */
+  static notOk<T = never, F = unknown>(failure: F): NotOk<F> {
+    // TypeScript cannot express discriminated return types for a single implementation.
+    // Cast is safe: ok=false guarantees this is a NotOk<F> at runtime.
+    return new ResultImpl<T, F>(false, failure) as unknown as NotOk<F>;
+  }
+
+  /**
+   * Asserts that this result is Ok and returns the value.
+   * Throws if the result is NotOk.
+   */
+  assertOk(this: Result<T, F>): T {
+    if (!this.ok) {
+      throw new Error('Expected Ok result but got NotOk');
+    }
+    return this.value;
+  }
+
+  /**
+   * Asserts that this result is NotOk and returns the failure.
+   * Throws if the result is Ok.
+   */
+  assertNotOk(this: Result<T, F>): F {
+    if (this.ok) {
+      throw new Error('Expected NotOk result but got Ok');
+    }
+    return this.failure;
+  }
+}
+
+/**
+ * Creates a successful result.
+ */
+export function ok<T>(value: T): Ok<T> {
+  return ResultImpl.ok(value);
+}
+
+/**
+ * Creates an unsuccessful result.
+ */
+export function notOk<F>(failure: F): NotOk<F> {
+  return ResultImpl.notOk(failure);
+}
+
+/**
+ * Singleton for void success results.
+ * Use this for validation checks that don't produce a value.
+ */
+const OK_VOID: Ok<void> = ResultImpl.ok<void>(undefined);
+
+/**
+ * Returns a successful void result.
+ * Use this for validation checks that don't produce a value.
+ */
+export function okVoid(): Ok<void> {
+  return OK_VOID;
+}