@dereekb/model 13.0.7 → 13.2.0

package/src/lib/transform/transform.d.ts

@@ -1,64 +1,93 @@
-import { type Maybe, type ClassType } from '@dereekb/util';
-import { type ClassTransformOptions } from 'class-transformer';
-import { type ValidationError, type ValidatorOptions } from 'class-validator';
+import { type Type, type ArkErrors } from 'arktype';
 export interface TransformAndValidateObjectOutput<T, O> {
     readonly object: T;
     readonly result: O;
 }
 export type TransformAndValidateObjectFunction<T, O, I extends object = object, C = unknown> = (input: I, context?: C) => Promise<TransformAndValidateObjectOutput<T, O>>;
-export type TransformAndValidateObjectHandleValidate<O = unknown> = (validationErrors: ValidationError[]) => Promise<O>;
+export type TransformAndValidateObjectHandleValidate<O = unknown> = (validationErrors: ArkErrors) => Promise<O>;
 /**
  * transformAndValidateObject() configuration that also provides error handling.
  */
 export interface TransformAndValidateObject<T extends object, O, C = unknown> extends TransformAndValidateObjectResultFunctionConfig<T, O, C> {
     readonly handleValidationError: TransformAndValidateObjectHandleValidate<O>;
 }
+/**
+ * Creates a function that validates input against an ArkType schema and then processes it.
+ *
+ * On validation success, calls the configured handler function. On validation failure, delegates to the error handler.
+ *
+ * @param config - schema, handler function, and validation error handler
+ * @returns a function that validates and processes input objects
+ *
+ * @example
+ * ```typescript
+ * const processUser = transformAndValidateObject({
+ *   schema: userType,
+ *   fn: async (user) => ({ id: user.id }),
+ *   handleValidationError: async (errors) => { throw new Error(errors.summary); }
+ * });
+ *
+ * const result = await processUser({ id: '123', name: 'John' });
+ * ```
+ */
 export declare function transformAndValidateObject<T extends object, O, I extends object = object, C = unknown>(config: TransformAndValidateObject<T, O, C>): TransformAndValidateObjectFunction<T, O, I, C>;
 /**
  * Configuration for the transformAndValidateObject function from transformAndValidateObjectFactory().
  */
-export interface TransformAndValidateObjectFactoryDefaults<C> extends Pick<TransformAndValidateObjectResultFunctionConfig<any, any, C>, 'defaultValidationOptions' | 'optionsForContext'> {
+export interface TransformAndValidateObjectFactoryDefaults<C> {
     readonly handleValidationError: TransformAndValidateObjectHandleValidate<unknown>;
 }
 /**
  * Factory for generating TransformAndValidateObjectFunction functions.
  */
-export type TransformAndValidateObjectFactory<C = unknown> = <T extends object, O, I extends object = object>(classType: ClassType<T>, fn: (parsed: T) => Promise<O>, handleValidationError?: TransformAndValidateObjectHandleValidate<O>) => TransformAndValidateObjectFunction<T, O, I, C>;
+export type TransformAndValidateObjectFactory<C = unknown> = <T extends object, O, I extends object = object>(schema: Type<T>, fn: (parsed: T) => Promise<O>, handleValidationError?: TransformAndValidateObjectHandleValidate<O>) => TransformAndValidateObjectFunction<T, O, I, C>;
 /**
- * Creates a new TransformAndValidateObjectFactory.
+ * Creates a reusable factory for generating transform-and-validate functions with shared defaults.
  *
- * @param defaults
- * @returns
+ * The factory pre-configures error handling so individual function calls
+ * only need to specify the schema and handler.
+ *
+ * @param defaults - default error handler
+ * @returns a factory function that creates TransformAndValidateObjectFunction instances
  */
 export declare function transformAndValidateObjectFactory<C = unknown>(defaults: TransformAndValidateObjectFactoryDefaults<C>): TransformAndValidateObjectFactory<C>;
 export type TransformAndValidateObjectResultFunction<T, O, I extends object = object, C = unknown> = (input: I, context?: C) => Promise<TransformAndValidateObjectResultOutput<T, O>>;
-export interface TransformAndValidateObjectResultTransformContextOptions {
-    readonly transform?: ClassTransformOptions;
-    readonly validate?: ValidatorOptions;
-}
-export type TransformAndValidateObjectResultContextOptionsFunction<C> = (context?: C) => TransformAndValidateObjectResultTransformContextOptions;
-export type TransformAndValidateObjectResultOutput<T, O> = TransformAndValidateObjectSuccessResultOutput<T, O> | TransformAndValidateObjectErrorResultOutput<T>;
+export type TransformAndValidateObjectResultOutput<T, O> = TransformAndValidateObjectSuccessResultOutput<T, O> | TransformAndValidateObjectErrorResultOutput;
 export interface TransformAndValidateObjectSuccessResultOutput<T, O> {
     readonly success: true;
     readonly object: T;
     readonly result: O;
 }
-export interface TransformAndValidateObjectErrorResultOutput<T> {
+export interface TransformAndValidateObjectErrorResultOutput {
     readonly success: false;
-    readonly object: T;
-    readonly validationErrors: ValidationError[];
+    readonly validationErrors: ArkErrors;
 }
 export interface TransformAndValidateObjectResultFunctionConfig<T extends object, O, C = unknown, I extends object = object> {
-    readonly defaultValidationOptions?: Maybe<ValidatorOptions>;
-    readonly classType: ClassType<T>;
+    readonly schema: Type<T>;
     readonly fn: (parsed: T) => Promise<O>;
-    readonly optionsForContext?: TransformAndValidateObjectResultContextOptionsFunction<C>;
 }
 /**
- * Factory function that wraps the input class type and handler function to first transform the input object to a the given class, and then validate it.
+ * Creates a function that validates input against an ArkType schema and returns a discriminated result.
+ *
+ * Returns `{ success: true, object, result }` on valid input, or `{ success: false, validationErrors }` on failure.
+ * The caller is responsible for handling the error case.
+ *
+ * @param config - schema and handler function
+ * @returns a function that returns a success/error discriminated result
+ *
+ * @example
+ * ```typescript
+ * const validateUser = transformAndValidateObjectResult({
+ *   schema: userType,
+ *   fn: async (user) => ({ saved: true })
+ * });
  *
- * @param classType
- * @param fn
- * @returns
+ * const result = await validateUser({ name: 'John' });
+ * if (result.success) {
+ *   console.log(result.result);
+ * } else {
+ *   console.log(result.validationErrors.summary);
+ * }
+ * ```
  */
 export declare function transformAndValidateObjectResult<T extends object, O, I extends object = object, C = unknown>(config: TransformAndValidateObjectResultFunctionConfig<T, O, C, I>): TransformAndValidateObjectResultFunction<T, O, I, C>;

package/src/lib/transform/transform.function.d.ts

@@ -1,4 +1,4 @@
-import { type ClassType } from '@dereekb/util';
+import { type Type } from 'arktype';
 import { type TransformAndValidateObjectFactory, type TransformAndValidateObjectFactoryDefaults, type TransformAndValidateObjectHandleValidate, type TransformAndValidateObjectOutput } from './transform';
 import { type TransformAndValidateResultFunction } from './transform.result';
 /**
@@ -8,8 +8,28 @@ export type TransformAndValidateFunctionResult<T extends object, O> = O & {
     params: T;
 };
 export type TransformAndValidateFunctionResultFunction<T extends object, O, I extends object = object, C = unknown> = TransformAndValidateResultFunction<TransformAndValidateFunctionResult<T, O>, I, C>;
-export type TransformAndValidateFunctionResultFactory<C = unknown> = <T extends object, O, I extends object = object>(classType: ClassType<T>, fn: (parsed: T) => Promise<O>, handleValidationError?: TransformAndValidateObjectHandleValidate<O>) => TransformAndValidateFunctionResultFunction<T, O, I, C>;
+export type TransformAndValidateFunctionResultFactory<C = unknown> = <T extends object, O, I extends object = object>(schema: Type<T>, fn: (parsed: T) => Promise<O>, handleValidationError?: TransformAndValidateObjectHandleValidate<O>) => TransformAndValidateFunctionResultFunction<T, O, I, C>;
+/**
+ * Creates a factory for transform-and-validate functions that return the result with the parsed object attached as `params`.
+ *
+ * @param defaults - shared error handler defaults
+ * @returns a factory that produces functions returning {@link TransformAndValidateFunctionResult}
+ */
 export declare function transformAndValidateFunctionResultFactory<C = unknown>(defaults: TransformAndValidateObjectFactoryDefaults<C>): TransformAndValidateFunctionResultFactory<C>;
+/**
+ * Wraps an existing {@link TransformAndValidateObjectFactory} to produce functions that attach the parsed object
+ * as `params` on the result.
+ *
+ * @param transformAndValidateObjectFactory - the base factory to wrap
+ * @returns a factory that produces functions returning results with `params` attached
+ */
 export declare function toTransformAndValidateFunctionResultFactory<C = unknown>(transformAndValidateObjectFactory: TransformAndValidateObjectFactory<C>): TransformAndValidateFunctionResultFactory<C>;
+/**
+ * Transforms a {@link TransformAndValidateObjectOutput} into a {@link TransformAndValidateFunctionResult}
+ * by attaching the parsed object as `params` on the result.
+ *
+ * @param objectOutput - the transform-and-validate output (sync or async)
+ * @returns the result with `params` attached
+ */
 export declare function toTransformAndValidateFunctionResult<T extends object, O>(objectOutput: Promise<TransformAndValidateObjectOutput<T, O>>): Promise<TransformAndValidateFunctionResult<T, O>>;
 export declare function toTransformAndValidateFunctionResult<T extends object, O>(objectOutput: TransformAndValidateObjectOutput<T, O>): TransformAndValidateFunctionResult<T, O>;

package/src/lib/transform/transform.result.d.ts

@@ -1,8 +1,16 @@
-import { type ClassType } from '@dereekb/util';
+import { type Type } from 'arktype';
 import { type TransformAndValidateObjectFactoryDefaults, type TransformAndValidateObjectHandleValidate } from './transform';
 /**
  * A TransformAndValidate function that returns only the result.
  */
 export type TransformAndValidateResultFunction<O, I extends object = object, C = unknown> = (input: I, context?: C) => Promise<O>;
-export type TransformAndValidateResultFactory<C = unknown> = <T extends object, O, I extends object = object>(classType: ClassType<T>, fn: (parsed: T) => Promise<O>, handleValidationError?: TransformAndValidateObjectHandleValidate<O>) => TransformAndValidateResultFunction<O, I, C>;
+export type TransformAndValidateResultFactory<C = unknown> = <T extends object, O, I extends object = object>(schema: Type<T>, fn: (parsed: T) => Promise<O>, handleValidationError?: TransformAndValidateObjectHandleValidate<O>) => TransformAndValidateResultFunction<O, I, C>;
+/**
+ * Creates a factory for transform-and-validate functions that return only the result (discarding the parsed object).
+ *
+ * Useful when you only need the processed output and don't need access to the validated input.
+ *
+ * @param defaults - shared error handler defaults
+ * @returns a factory that produces functions returning only the handler's result
+ */
 export declare function transformAndValidateResultFactory<C = unknown>(defaults: TransformAndValidateObjectFactoryDefaults<C>): TransformAndValidateResultFactory<C>;

package/src/lib/type/index.d.ts

@@ -0,0 +1,2 @@
+export * from './model';
+export * from './type';

package/src/lib/type/model.d.ts

@@ -0,0 +1,20 @@
+/**
+ * ArkType schema for a model key (non-empty string).
+ */
+export declare const modelKeyType: import("arktype/internal/variants/string.ts").StringType<string, {}>;
+/**
+ * ArkType schema for a model id (non-empty string).
+ */
+export declare const modelIdType: import("arktype/internal/variants/string.ts").StringType<string, {}>;
+/**
+ * ArkType schema for target model params with a required `key` field.
+ */
+export declare const targetModelParamsType: import("arktype/internal/variants/object.ts").ObjectType<{
+    key: string;
+}, {}>;
+/**
+ * ArkType schema for target model id params with a required `id` field.
+ */
+export declare const targetModelIdParamsType: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+}, {}>;

package/src/lib/type/type.d.ts

@@ -0,0 +1,21 @@
+import { type type, type Type } from 'arktype';
+/**
+ * Creates an ArkType schema that accepts the given ArkType definition OR null/undefined.
+ * Used for fields where null acts as a "clear/reset" signal for the model.
+ *
+ * The dbx-components library uses null in API calls to signal that something can be deleted entirely,
+ * whereas undefined is simply treated as an ignore.
+ *
+ * Accepts either a string definition or a Type instance.
+ *
+ * @example
+ * ```typescript
+ * const schema = type({
+ *   "sdat?": clearable("string.date.parse"),          // string definition
+ *   "phone?": clearable(e164PhoneNumberType),          // Type instance
+ *   "items?": clearable(mySchemaType.array()),          // .array() result
+ * });
+ * ```
+ */
+export declare function clearable<const def extends string>(definition: def): Type<type.infer<def> | null | undefined>;
+export declare function clearable<T>(definition: Type<T>): Type<T | null | undefined>;

package/src/lib/validator/date.d.ts

@@ -1,6 +1,4 @@
-import { type ObjectWithConstructor } from '@dereekb/util';
-import { type ValidationOptions } from 'class-validator';
 /**
- * isISO8601DayString validator
+ * ArkType schema for a valid ISO 8601 day string (e.g., "2024-01-15").
  */
-export declare function IsISO8601DayString(validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare const iso8601DayStringType: import("arktype/internal/variants/string.ts").StringType<string, {}>;

package/src/lib/validator/number.d.ts

@@ -1,6 +1,4 @@
-import { type ObjectWithConstructor } from '@dereekb/util';
-import { type ValidationOptions } from 'class-validator';
 /**
- * isMinuteOfDay validator
+ * ArkType schema for a valid minute of the day (0-1439).
  */
-export declare function IsMinuteOfDay(validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare const minuteOfDayType: import("arktype/internal/variants/number.ts").NumberType<number, {}>;

package/src/lib/validator/phone.d.ts

@@ -1,20 +1,12 @@
-import { type ObjectWithConstructor } from '@dereekb/util';
-import { type ValidationOptions } from 'class-validator';
 /**
- * isE164PhoneNumber validator that does not allowed extensions.
+ * ArkType schema for a valid E.164 phone number without an extension.
  */
-export declare function IsE164PhoneNumber(validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare const e164PhoneNumberType: import("arktype/internal/variants/string.ts").StringType<string, {}>;
 /**
- * isE164PhoneNumber validator that allows extensions.
- *
- * @param validationOptions
- * @returns
+ * ArkType schema for a valid E.164 phone number, optionally with an extension.
  */
-export declare function IsE164PhoneNumberWithOptionalExtension(validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare const e164PhoneNumberWithOptionalExtensionType: import("arktype/internal/variants/string.ts").StringType<string, {}>;
 /**
- * isE164PhoneNumberWithExtension validator
- *
- * @param validationOptions
- * @returns
+ * ArkType schema for a valid E.164 phone number that includes an extension.
  */
-export declare function IsE164PhoneNumberWithExtension(validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare const e164PhoneNumberWithExtensionType: import("arktype/internal/variants/string.ts").StringType<string, {}>;

package/src/lib/validator/unique.d.ts

@@ -1,6 +1,13 @@
-import { type ObjectWithConstructor, type ReadKeyFunction } from '@dereekb/util';
-import { type ValidationOptions } from 'class-validator';
+import { type ReadKeyFunction } from '@dereekb/util';
 /**
- * isUniqueKeyedFunction validator
+ * Creates an ArkType schema that validates an array has no duplicate keys.
+ *
+ * @param readKey - function that extracts the key from each array element
+ * @returns an ArkType schema that narrows `T[]` to ensure uniqueness
+ *
+ * @example
+ * ```typescript
+ * const uniqueItemsType = uniqueKeyedType((item: Item) => item.id);
+ * ```
  */
-export declare function IsUniqueKeyed<T>(readKey: ReadKeyFunction<T>, validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare function uniqueKeyedType<T>(readKey: ReadKeyFunction<T>): import("arktype/internal/variants/array.ts").ArrayType<unknown[], {}>;

package/src/lib/validator/url.d.ts

@@ -1,10 +1,8 @@
-import { type ObjectWithConstructor } from '@dereekb/util';
-import { type ValidationOptions } from 'class-validator';
 /**
- * isWebsiteUrl validator
+ * ArkType schema for a valid website URL (with or without protocol prefix).
  */
-export declare function IsWebsiteUrl(validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare const websiteUrlType: import("arktype/internal/variants/string.ts").StringType<string, {}>;
 /**
- * isWebsiteUrlWithPrefix validator
+ * ArkType schema for a valid website URL that starts with `http://` or `https://`.
  */
-export declare function IsWebsiteUrlWithPrefix(validationOptions?: ValidationOptions): (object: ObjectWithConstructor, propertyName: string) => void;
+export declare const websiteUrlWithPrefixType: import("arktype/internal/variants/string.ts").StringType<string, {}>;

package/src/lib/transform/type.annotation.d.ts

@@ -1,5 +0,0 @@
-import { type MapStringFunction } from '@dereekb/util';
-export declare function TransformCommaSeparatedValueToArray<T>(mapFn: MapStringFunction<T>): PropertyDecorator;
-export declare const TransformCommaSeparatedStringValueToArray: () => PropertyDecorator;
-export declare const TransformCommaSeparatedNumberValueToArray: () => PropertyDecorator;
-export declare const TransformStringValueToBoolean: () => PropertyDecorator;

package/src/lib/transform/type.d.ts

@@ -1,6 +0,0 @@
-import { type MapStringFunction, type Maybe } from '@dereekb/util';
-import { type TransformFnParams } from 'class-transformer';
-export declare function transformStringToBoolean(defaultValue?: boolean | undefined): (params: TransformFnParams) => Maybe<boolean>;
-export declare function transformCommaSeparatedValueToArray<T>(mapFn: MapStringFunction<T>): (params: TransformFnParams) => Maybe<T[]>;
-export declare const transformCommaSeparatedNumberValueToArray: (params: TransformFnParams) => Maybe<number[]>;
-export declare const transformCommaSeparatedStringValueToArray: (params: TransformFnParams) => Maybe<string[]>;