typescript-type 0.0.14 → 0.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-type",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "Typescript type",
   "scripts": {
     "clean": "rm -rf node_modules/ && rm -rf .nyc_output/ && rm -rf package-lock.json"

package/patterns/driver.ts

@@ -64,11 +64,18 @@ export abstract class Driver<Config = any> {
   ): T => {
     try {
       // Check if it's a SchemaDefinition (has .parse method)
-      if ('parse' in schema && typeof schema.parse === 'function') {
+      if (schema && typeof schema === 'object' && 'parse' in schema && typeof (schema as any).parse === 'function') {
         return (schema as SchemaDefinition<T>).parse(rawData);
       }
-      // Otherwise it's a raw Type
-      return parseSync(schema as Type<T>, rawData);
+      // Check if schema is callable (arktype Type)
+      if (typeof schema === 'function') {
+        return parseSync(schema as Type<T>, rawData);
+      }
+      // Try using .schema property if available (SchemaDefinition)
+      if (schema && typeof schema === 'object' && 'schema' in schema) {
+        return parseSync((schema as any).schema as Type<T>, rawData);
+      }
+      throw new Error(`Invalid schema type: ${typeof schema}`);
     } catch (error: any) {
       throw new BadConfigException([error.message || String(error)]);
     }

package/patterns/validator.ts

@@ -35,31 +35,44 @@ export type SafeParseResult<T> = ValidationResult<T> | ValidationError;
 // Core Validator Factory
 // ============================================================================
 
+/**
+ * Check if a value is an arktype Type object (not a lazy factory function)
+ * Arktype Types are callable but also have special properties like 'expression'
+ */
+function isArktypeType(value: unknown): boolean {
+  return (
+    typeof value === 'function' &&
+    value !== null &&
+    typeof (value as any).expression === 'string'
+  );
+}
+
 export function createValidator<T>(schema: any) {
   const syncChecks: SyncCheck<T>[] = [];
   const asyncChecks: AsyncCheck<T>[] = [];
   let lazySchemaCache: any = null;
 
   function valueData(data: T) {
-    const currentSchema = typeof schema === 'function' ? schema() : schema;
-    // Handle arktype Type objects (they're callable but also have a .assert method)
+    // If schema is a lazy factory function (not an arktype Type), call it to get the actual schema
+    const currentSchema = (typeof schema === 'function' && !isArktypeType(schema))
+      ? schema()
+      : schema;
+
+    // Arktype Types are callable - call them directly with the data
     let result: SchemaResult<T>;
-    if (typeof currentSchema === 'function') {
+    if (isArktypeType(currentSchema)) {
+      // Arktype Type - call it directly
+      result = currentSchema(data);
+    } else if (typeof currentSchema === 'function') {
+      // Some other callable schema
       result = currentSchema(data);
     } else if (currentSchema && typeof currentSchema.assert === 'function') {
-      // arktype Type with .assert method
+      // Schema with .assert method
       try {
         result = { data: currentSchema.assert(data) };
       } catch (e: any) {
         result = { problems: { summary: e.message || String(e) } };
       }
-    } else if (currentSchema && typeof currentSchema === 'object') {
-      // Try calling it as a function (arktype types are callable)
-      try {
-        result = currentSchema(data);
-      } catch (e: any) {
-        throw new Error(`Schema is not callable: ${e.message || String(e)}`);
-      }
     } else {
       throw new Error('Invalid schema provided to validator');
     }
@@ -119,7 +132,11 @@ function _runValidation(
   data: unknown,
   options: ParseOptionsSync = {}
 ): { data: any; validator: ReturnType<typeof createValidator> } {
-  const schema = typeof types === 'function' ? types() : types;
+  // If it's a function but NOT an arktype Type, assume it's a lazy factory
+  // Arktype Types are callable but have an 'expression' property
+  const schema = (typeof types === 'function' && !isArktypeType(types))
+    ? types()
+    : types;
   const validator = options.validator ?? createValidator(schema);
   if (options.checks) for (const fn of options.checks) validator.check(fn);
   const result = validator.validate(data);