Merge pull request #84 from monarch-orm/extend-types

Preserve type instance with type modifier methods

Author: eriicafes

.changeset/kind-areas-fix.md

@@ -0,0 +1,5 @@
+---
+"monarch-orm": patch
+---
+
+Preserve concrete type with type modifier methods

src/types/array.ts

@@ -39,20 +39,22 @@ export class MonarchArray<T extends AnyMonarchType> extends MonarchType<InferTyp
     this.elementType = type;
   }
 
+  protected copy() {
+    return new MonarchArray(this.elementType);
+  }
+
   /**
    * Validates minimum array length.
    *
    * @param length - Minimum length
    * @returns MonarchArray with length validation
    */
   public min(length: number) {
-    return array(this.elementType).extend(this, {
-      parse: (input) => {
-        if (input.length < length) {
-          throw new MonarchParseError(`array must have at least ${length} elements`);
-        }
-        return input;
-      },
+    return this.parse((input) => {
+      if (input.length < length) {
+        throw new MonarchParseError(`array must have at least ${length} elements`);
+      }
+      return input;
     });
   }
 
@@ -63,13 +65,11 @@ export class MonarchArray<T extends AnyMonarchType> extends MonarchType<InferTyp
    * @returns MonarchArray with length validation
    */
   public max(length: number) {
-    return array(this.elementType).extend(this, {
-      parse: (input) => {
-        if (input.length > length) {
-          throw new MonarchParseError(`array must have at most ${length} elements`);
-        }
-        return input;
-      },
+    return this.parse((input) => {
+      if (input.length > length) {
+        throw new MonarchParseError(`array must have at most ${length} elements`);
+      }
+      return input;
     });
   }
 
@@ -80,13 +80,11 @@ export class MonarchArray<T extends AnyMonarchType> extends MonarchType<InferTyp
    * @returns MonarchArray with length validation
    */
   public length(length: number) {
-    return array(this.elementType).extend(this, {
-      parse: (input) => {
-        if (input.length !== length) {
-          throw new MonarchParseError(`array must have exactly ${length} elements`);
-        }
-        return input;
-      },
+    return this.parse((input) => {
+      if (input.length !== length) {
+        throw new MonarchParseError(`array must have exactly ${length} elements`);
+      }
+      return input;
     });
   }
 
@@ -96,6 +94,11 @@ export class MonarchArray<T extends AnyMonarchType> extends MonarchType<InferTyp
    * @returns MonarchArray with non-empty validation
    */
   public nonempty() {
-    return this.min(1);
+    return this.parse((input) => {
+      if (input.length === 0) {
+        throw new MonarchParseError("array must not be empty");
+      }
+      return input;
+    });
   }
 }

src/types/binary.ts

@@ -20,4 +20,8 @@ export class MonarchBinary extends MonarchType<Buffer | Binary, Binary> {
       throw new MonarchParseError(`expected 'Buffer' or 'Binary' received '${typeof input}'`);
     });
   }
+
+  protected copy() {
+    return new MonarchBinary();
+  }
 }

src/types/boolean.ts

@@ -18,4 +18,8 @@ export class MonarchBoolean extends MonarchType<boolean, boolean> {
       throw new MonarchParseError(`expected 'boolean' received '${typeof input}'`);
     });
   }
+
+  protected copy() {
+    return new MonarchBoolean();
+  }
 }

src/types/date.ts

@@ -19,20 +19,22 @@ export class MonarchDate extends MonarchType<Date, Date> {
     });
   }
 
+  protected copy() {
+    return new MonarchDate();
+  }
+
   /**
    * Validates date is after a target date.
    *
    * @param targetDate - Target date for comparison
    * @returns MonarchDate with after validation
    */
   public after(targetDate: Date) {
-    return date().extend(this, {
-      parse: (input) => {
-        if (input <= targetDate) {
-          throw new MonarchParseError(`date must be after ${targetDate.toISOString()}`);
-        }
-        return input;
-      },
+    return this.parse((input) => {
+      if (input <= targetDate) {
+        throw new MonarchParseError(`date must be after ${targetDate.toISOString()}`);
+      }
+      return input;
     });
   }
 
@@ -43,13 +45,11 @@ export class MonarchDate extends MonarchType<Date, Date> {
    * @returns MonarchDate with before validation
    */
   public before(targetDate: Date) {
-    return date().extend(this, {
-      parse: (input) => {
-        if (input >= targetDate) {
-          throw new MonarchParseError(`date must be before ${targetDate.toISOString()}`);
-        }
-        return input;
-      },
+    return this.parse((input) => {
+      if (input >= targetDate) {
+        throw new MonarchParseError(`date must be before ${targetDate.toISOString()}`);
+      }
+      return input;
     });
   }
 }
@@ -66,10 +66,7 @@ export const createdAt = () => date().default(() => new Date());
  *
  * @returns MonarchDate with update and default values
  */
-export const updatedAt = () => {
-  const base = date();
-  return base.extend(base, { onUpdate: () => new Date() }).default(() => new Date());
-};
+export const updatedAt = () => createdAt().onUpdate(() => new Date());
 
 /**
  * Date string type that accepts ISO date strings.
@@ -91,20 +88,22 @@ export class MonarchDateString extends MonarchType<string, Date> {
     });
   }
 
+  protected copy() {
+    return new MonarchDateString();
+  }
+
   /**
    * Validates date is after a target date.
    *
    * @param targetDate - Target date for comparison
    * @returns MonarchDateString with after validation
    */
   public after(targetDate: Date) {
-    return dateString().extend(this, {
-      parse: (input) => {
-        if (input <= targetDate) {
-          throw new MonarchParseError(`date must be after ${targetDate.toISOString()}`);
-        }
-        return input;
-      },
+    return this.parse((input: Date) => {
+      if (input <= targetDate) {
+        throw new MonarchParseError(`date must be after ${targetDate.toISOString()}`);
+      }
+      return input;
     });
   }
 
@@ -115,13 +114,11 @@ export class MonarchDateString extends MonarchType<string, Date> {
    * @returns MonarchDateString with before validation
    */
   public before(targetDate: Date) {
-    return dateString().extend(this, {
-      parse: (input) => {
-        if (input >= targetDate) {
-          throw new MonarchParseError(`date must be before ${targetDate.toISOString()}`);
-        }
-        return input;
-      },
+    return this.parse((input: Date) => {
+      if (input >= targetDate) {
+        throw new MonarchParseError(`date must be before ${targetDate.toISOString()}`);
+      }
+      return input;
     });
   }
 }

src/types/decimal128.ts

@@ -20,4 +20,8 @@ export class MonarchDecimal128 extends MonarchType<Decimal128 | string, Decimal1
       throw new MonarchParseError(`expected 'Decimal128' or 'string' received '${typeof input}'`);
     });
   }
+
+  protected copy() {
+    return new MonarchDecimal128();
+  }
 }

src/types/index.ts

@@ -21,7 +21,6 @@ export {
   defaulted,
   nullable,
   optional,
-  pipeParser,
   type,
   type AnyMonarchType,
   type Parser,

src/types/literal.ts

@@ -13,11 +13,15 @@ export const literal = <T extends string | number | boolean>(...values: T[]) =>
  * Type for literal fields.
  */
 export class MonarchLiteral<T extends string | number | boolean> extends MonarchType<T, T> {
-  constructor(values: T[]) {
+  constructor(private values: T[]) {
     super((input) => {
       const _values = new Set(values);
       if (_values.has(input)) return input;
       throw new MonarchParseError(`unknown value '${input}', literal may only specify known values`);
     });
   }
+
+  protected copy() {
+    return new MonarchLiteral(this.values);
+  }
 }

src/types/long.ts

@@ -27,4 +27,8 @@ export class MonarchLong extends MonarchType<Long | number | bigint, Long | numb
       throw new MonarchParseError(`expected 'Long', 'number', or 'bigint' received '${typeof input}'`);
     });
   }
+
+  protected copy() {
+    return new MonarchLong();
+  }
 }

src/types/mixed.ts

@@ -16,4 +16,8 @@ export class MonarchMixed extends MonarchType<unknown, unknown> {
       return input;
     });
   }
+
+  protected copy() {
+    return new MonarchMixed();
+  }
 }