schemantic 0.3.0 → 0.4.0

package/dist/plugins/branded-types.js

@@ -23,6 +23,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.brandedTypesPlugin = void 0;
 const schema_1 = require("../types/schema");
+const zod_validation_1 = require("./zod-validation");
 /**
  * Advanced Branded Types Plugin Implementation
  */
@@ -62,25 +63,29 @@ exports.brandedTypesPlugin = {
      */
     afterTypeGeneration: async (typeName, generatedType, context) => {
         const options = getPluginOptions(context);
-        if (!options.enabled || !generatedType.isInterface) {
+        if (!options.enabled) {
             return;
         }
-        try {
-            const brandedCode = generateBrandedTypeEnhancements(typeName, generatedType, options);
-            if (brandedCode) {
-                generatedType.content += brandedCode;
-                // Update exports
-                generatedType.exports.push(`Branded${typeName}`, `create${typeName}`, `is${typeName}`, `assert${typeName}`);
-                if (options.enablePhantomTypes) {
-                    generatedType.exports.push(`${typeName}WithAuth`, `authorize${typeName}`, `unauthorize${typeName}`);
-                }
-                if (options.enableDiscriminatedUnions) {
-                    generatedType.exports.push(`${typeName}Union`, `match${typeName}`, `is${typeName}Variant`);
+        const brandedCode = generateBrandedTypeEnhancements(typeName, generatedType, options, context);
+        if (brandedCode) {
+            generatedType.content += brandedCode;
+            generatedType.dependencies.push("zod");
+            generatedType.exports.push(`Branded${typeName}`, `create${typeName}`);
+            if (options.enableRuntimeGuards)
+                generatedType.exports.push(`is${typeName}`);
+            if (options.enableAssertionFunctions)
+                generatedType.exports.push(`assert${typeName}`);
+            if (options.enableOpaqueTypes)
+                generatedType.exports.push(`Opaque${typeName}`, `createOpaque${typeName}`, `unwrapOpaque${typeName}`);
+            if (options.enablePhantomTypes && generatedType.isInterface) {
+                generatedType.exports.push(`${typeName}WithAuth`, `authorize${typeName}`, `unauthorize${typeName}`, `isAuthenticated${typeName}`);
+                if (!Array.from(context.generatedTypes.values()).some(type => type !== generatedType && type.exports.includes("AuthState"))) {
+                    generatedType.content += "\nexport type AuthState = 'authenticated' | 'unauthenticated';\n";
+                    generatedType.exports.push("AuthState");
                 }
             }
-        }
-        catch (error) {
-            console.warn(`Branded types plugin afterTypeGeneration failed for ${typeName}:`, error);
+            if (options.enableDiscriminatedUnions)
+                generatedType.exports.push(`${typeName}Union`, `match${typeName}`, `is${typeName}Variant`);
         }
     },
     /**
@@ -91,20 +96,15 @@ exports.brandedTypesPlugin = {
         if (!options.enabled) {
             return;
         }
-        try {
-            const clientEnhancements = generateClientBrandedTypeIntegration(generatedClient, options);
-            if (clientEnhancements) {
-                generatedClient.content += clientEnhancements;
-                // Update exports
-                generatedClient.exports.push("BrandedApiClient", "TypeSafeApiClient", "withBrandValidation");
-                if (options.enablePhantomTypes) {
-                    generatedClient.exports.push("AuthenticatedApiClient", "UnauthenticatedApiClient");
-                }
+        const clientEnhancements = generateClientBrandedTypeIntegration(generatedClient, options);
+        if (clientEnhancements) {
+            generatedClient.content += clientEnhancements;
+            // Update exports
+            generatedClient.exports.push("BrandedApiClient", "withBrandValidation");
+            if (options.enablePhantomTypes) {
+                generatedClient.exports.push("TypeSafeApiClient", "AuthenticatedApiClient", "UnauthenticatedApiClient");
             }
         }
-        catch (error) {
-            console.warn("Branded types plugin afterClientGeneration failed:", error);
-        }
     },
 };
 /**
@@ -188,379 +188,245 @@ function extractValidationConstraints(schema) {
 /**
  * Generate branded type enhancements for a given type
  */
-function generateBrandedTypeEnhancements(typeName, generatedType, options) {
-    if (!(0, schema_1.isOpenAPISchemaObject)(generatedType.sourceSchema)) {
-        return "";
-    }
-    const schema = generatedType.sourceSchema;
-    const brandMetadata = schema._brandMetadata || {};
-    if (!brandMetadata.shouldBrand) {
-        return generateBasicBrandedType(typeName, options);
-    }
-    return generateAdvancedBrandedType(typeName, schema, options, brandMetadata);
+function generateBrandedTypeEnhancements(typeName, generatedType, options, context) {
+    const marker = options.brandIdentifier ?? "Brand";
+    const brandName = options.brandNamingConvention === "suffix" ? `${typeName}${marker}`
+        : options.brandNamingConvention === "namespace" ? `${marker}.${typeName}` : `${marker}${typeName}`;
+    const validator = (0, zod_validation_1.buildZodSchema)(generatedType.sourceSchema, { strictMode: false }, 0, context).replace(/z\.lazy\(\(\) => (\w+)Schema\)/g, "z.lazy(() => __$1BrandSchema)");
+    const constraints = options.enableTypeLevelValidations && (0, schema_1.isOpenAPISchemaObject)(generatedType.sourceSchema)
+        ? `; readonly __constraints: ${JSON.stringify(extractValidationConstraints(generatedType.sourceSchema))}` : "";
+    return `
+import { z } from 'zod';
+const __${typeName}BrandSchema: z.ZodType = ${validator};
+export type Branded${typeName} = ${typeName} & { readonly __brand: ${JSON.stringify(brandName)}${constraints} };
+/** Validates the source schema before applying a compile-time brand. */
+export function create${typeName}(data: ${typeName}): Branded${typeName} {
+  __${typeName}BrandSchema.parse(data); return data as Branded${typeName};
 }
-/**
- * Generate basic branded type without specific validation
- */
-function generateBasicBrandedType(typeName, options) {
-    const brandName = `${typeName}${options.brandIdentifier || "Brand"}`;
-    return `
-
-/**
- * Branded type for ${typeName} with compile-time safety guarantees
- */
-export type Branded${typeName} = ${typeName} & { readonly __brand: '${brandName}' };
-
-/**
- * Create a branded ${typeName} instance
- */
-export function create${typeName}(data: ${typeName}): Branded${typeName} {
-  // Runtime validation would go here
-  return data as Branded${typeName};
-}
-
-/**
- * Type guard for Branded${typeName}
- */
-export function is${typeName}(value: unknown): value is Branded${typeName} {
-  // Basic type checking
-  return typeof value === 'object' && value !== null;
-}
-
-/**
- * Assertion function for ${typeName}
- */
-export function assert${typeName}(value: unknown): asserts value is Branded${typeName} {
-  if (!is${typeName}(value)) {
-    throw new Error(\`Expected ${typeName}, got \${typeof value}\`);
-  }
-}${options.enablePhantomTypes ? generatePhantomTypes(typeName) : ""}${options.enableDiscriminatedUnions
-        ? generateDiscriminatedUnions(typeName)
-        : ""}`;
+${options.enableRuntimeGuards ? `export function is${typeName}(value: unknown): ${options.enableTypePredicates ? `value is Branded${typeName}` : 'boolean'} { return __${typeName}BrandSchema.safeParse(value).success; }` : ''}
+${options.enableAssertionFunctions ? `export function assert${typeName}(value: unknown): asserts value is Branded${typeName} { __${typeName}BrandSchema.parse(value); }` : ''}
+${options.enableOpaqueTypes ? generateOpaqueTypeHelpers(typeName) : ''}
+${options.enablePhantomTypes && generatedType.isInterface ? generatePhantomTypes(typeName) : ''}
+${options.enableDiscriminatedUnions ? generateDiscriminatedUnions(typeName) : ''}
+`;
 }
 /**
- * Generate advanced branded type with validation constraints
+ * Generate opaque type helpers
  */
-function generateAdvancedBrandedType(typeName, schema, options, brandMetadata) {
-    const brandName = `${typeName}${options.brandIdentifier || "Brand"}`;
-    const validationCode = generateValidationCode(schema, brandMetadata);
-    return `
-
-/**
- * Advanced branded type for ${typeName} with validation constraints
- * Constraints: ${Array.isArray(brandMetadata.validationConstraints)
-        ? brandMetadata.validationConstraints.join(", ")
-        : "none"}
- */
-export type Branded${typeName} = ${typeName} & { 
-  readonly __brand: '${brandName}';
-  readonly __constraints: {${generateConstraintTypes(schema)}};
-};
-
-/**
- * Create a validated branded ${typeName} instance
- */
-export function create${typeName}(data: ${typeName}): Branded${typeName} {
-  ${validationCode}
-  return data as Branded${typeName};
-}
-
-/**
- * Advanced type guard with constraint validation
- */
-export function is${typeName}(value: unknown): value is Branded${typeName} {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-  
-  try {
-    create${typeName}(value as ${typeName});
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Assertion function with detailed error messages
- */
-export function assert${typeName}(value: unknown): asserts value is Branded${typeName} {
-  if (!is${typeName}(value)) {
-    throw new TypeError(\`Value does not satisfy ${typeName} constraints\`);
-  }
-}
-
-${options.enableOpaqueTypes ? generateOpaqueTypeHelpers(typeName) : ""}${options.enablePhantomTypes ? generatePhantomTypes(typeName) : ""}${options.enableDiscriminatedUnions
-        ? generateDiscriminatedUnions(typeName)
-        : ""}`;
-}
+function generateOpaqueTypeHelpers(typeName) {
+    return `
+
 /**
- * Generate validation code based on schema constraints
+ * Opaque type for ${typeName} - completely hides the underlying type
  */
-function generateValidationCode(schema, _brandMetadata) {
-    const validations = [];
-    if (schema.type === "string") {
-        if (schema.minLength !== undefined) {
-            validations.push(`if (typeof data !== 'string' || data.length < ${schema.minLength}) throw new Error('String too short');`);
-        }
-        if (schema.maxLength !== undefined) {
-            validations.push(`if (typeof data !== 'string' || data.length > ${schema.maxLength}) throw new Error('String too long');`);
-        }
-        if (schema.pattern) {
-            validations.push(`if (typeof data !== 'string' || !/${schema.pattern}/.test(data)) throw new Error('Pattern mismatch');`);
-        }
-    }
-    if (schema.type === "number" || schema.type === "integer") {
-        if (schema.minimum !== undefined) {
-            validations.push(`if (typeof data !== 'number' || data < ${schema.minimum}) throw new Error('Number too small');`);
-        }
-        if (schema.maximum !== undefined) {
-            validations.push(`if (typeof data !== 'number' || data > ${schema.maximum}) throw new Error('Number too large');`);
-        }
-    }
-    return validations.join("\n  ");
-}
+declare const __${typeName}Opaque: unique symbol;
+export type Opaque${typeName} = ${typeName} & { readonly [__${typeName}Opaque]: true };
+
 /**
- * Generate constraint types for the brand
+ * Create opaque ${typeName}
  */
-function generateConstraintTypes(schema) {
-    const constraints = [];
-    if (schema.minLength !== undefined) {
-        constraints.push(`minLength: ${schema.minLength}`);
-    }
-    if (schema.maxLength !== undefined) {
-        constraints.push(`maxLength: ${schema.maxLength}`);
-    }
-    if (schema.minimum !== undefined) {
-        constraints.push(`minimum: ${schema.minimum}`);
-    }
-    if (schema.maximum !== undefined) {
-        constraints.push(`maximum: ${schema.maximum}`);
-    }
-    if (schema.pattern) {
-        constraints.push(`pattern: '${schema.pattern}'`);
-    }
-    return constraints.join("; ");
+export function createOpaque${typeName}(data: ${typeName}): Opaque${typeName} {
+  __${typeName}BrandSchema.parse(data); return data as Opaque${typeName};
 }
+
 /**
- * Generate opaque type helpers
+ * Unwrap opaque ${typeName}
  */
-function generateOpaqueTypeHelpers(typeName) {
-    return `
-
-/**
- * Opaque type for ${typeName} - completely hides the underlying type
- */
-declare const __${typeName}Opaque: unique symbol;
-export type Opaque${typeName} = ${typeName} & { readonly [__${typeName}Opaque]: true };
-
-/**
- * Create opaque ${typeName}
- */
-export function createOpaque${typeName}(data: ${typeName}): Opaque${typeName} {
-  return data as Opaque${typeName};
-}
-
-/**
- * Unwrap opaque ${typeName}
- */
-export function unwrapOpaque${typeName}(data: Opaque${typeName}): ${typeName} {
-  return data as ${typeName};
+export function unwrapOpaque${typeName}(data: Opaque${typeName}): ${typeName} {
+  return data as ${typeName};
 }`;
 }
 /**
  * Generate phantom types for authentication state management
  */
 function generatePhantomTypes(typeName) {
-    return `
-
-/**
- * Phantom types for authentication state management
- */
-export type AuthState = 'authenticated' | 'unauthenticated';
-
-export type ${typeName}WithAuth<TAuth extends AuthState = 'unauthenticated'> = 
-  Branded${typeName} & { readonly __auth: TAuth };
-
-/**
- * Authorize a ${typeName} instance
- */
-export function authorize${typeName}(
-  data: ${typeName}WithAuth<'unauthenticated'>
-): ${typeName}WithAuth<'authenticated'> {
-  return data as ${typeName}WithAuth<'authenticated'>;
-}
-
-/**
- * Remove authorization from ${typeName} instance
- */
-export function unauthorize${typeName}(
-  data: ${typeName}WithAuth<'authenticated'>
-): ${typeName}WithAuth<'unauthenticated'> {
-  return data as ${typeName}WithAuth<'unauthenticated'>;
-}
-
-/**
- * Type guard for authenticated ${typeName}
- */
-export function isAuthenticated${typeName}(
-  value: ${typeName}WithAuth<AuthState>
-): value is ${typeName}WithAuth<'authenticated'> {
-  // In practice, this would check actual auth state
-  return true; // Placeholder implementation
+    return `
+
+/**
+ * Phantom types for authentication state management
+ */
+
+export type ${typeName}WithAuth<TAuth extends AuthState = 'unauthenticated'> = 
+  Branded${typeName} & { readonly __auth: TAuth };
+
+/**
+ * Authorize a ${typeName} instance
+ */
+export function authorize${typeName}(
+  data: ${typeName}WithAuth<'unauthenticated'>
+): ${typeName}WithAuth<'authenticated'> {
+  return { ...data, __auth: 'authenticated' };
+}
+
+/**
+ * Remove authorization from ${typeName} instance
+ */
+export function unauthorize${typeName}(
+  data: ${typeName}WithAuth<'authenticated'>
+): ${typeName}WithAuth<'unauthenticated'> {
+  return { ...data, __auth: 'unauthenticated' };
+}
+
+/**
+ * Type guard for authenticated ${typeName}
+ */
+export function isAuthenticated${typeName}(
+  value: ${typeName}WithAuth<AuthState>
+): value is ${typeName}WithAuth<'authenticated'> {
+  return value.__auth === 'authenticated';
 }`;
 }
 /**
  * Generate discriminated unions
  */
 function generateDiscriminatedUnions(typeName) {
-    return `
-
-/**
- * Discriminated union variants for ${typeName}
- */
-export type ${typeName}Union = 
-  | { type: 'valid'; data: Branded${typeName} }
-  | { type: 'invalid'; error: string }
-  | { type: 'pending'; progress?: number };
-
-/**
- * Pattern matching for ${typeName}Union
- */
-export function match${typeName}<T>(
-  union: ${typeName}Union,
-  handlers: {
-    valid: (data: Branded${typeName}) => T;
-    invalid: (error: string) => T;
-    pending: (progress?: number) => T;
-  }
-): T {
-  switch (union.type) {
-    case 'valid':
-      return handlers.valid(union.data);
-    case 'invalid':
-      return handlers.invalid(union.error);
-    case 'pending':
-      return handlers.pending(union.progress);
-    default:
-      // Exhaustiveness check
-      const _exhaustive: never = union;
-      throw new Error(\`Unhandled union type: \${JSON.stringify(_exhaustive)}\`);
-  }
-}
-
-/**
- * Type guard for ${typeName}Union variants
- */
-export function is${typeName}Variant<T extends ${typeName}Union['type']>(
-  union: ${typeName}Union,
-  type: T
-): union is Extract<${typeName}Union, { type: T }> {
-  return union.type === type;
+    return `
+
+/**
+ * Discriminated union variants for ${typeName}
+ */
+export type ${typeName}Union = 
+  | { type: 'valid'; data: Branded${typeName} }
+  | { type: 'invalid'; error: string }
+  | { type: 'pending'; progress?: number };
+
+/**
+ * Pattern matching for ${typeName}Union
+ */
+export function match${typeName}<T>(
+  union: ${typeName}Union,
+  handlers: {
+    valid: (data: Branded${typeName}) => T;
+    invalid: (error: string) => T;
+    pending: (progress?: number) => T;
+  }
+): T {
+  switch (union.type) {
+    case 'valid':
+      return handlers.valid(union.data);
+    case 'invalid':
+      return handlers.invalid(union.error);
+    case 'pending':
+      return handlers.pending(union.progress);
+    default:
+      // Exhaustiveness check
+      const _exhaustive: never = union;
+      throw new Error(\`Unhandled union type: \${JSON.stringify(_exhaustive)}\`);
+  }
+}
+
+/**
+ * Type guard for ${typeName}Union variants
+ */
+export function is${typeName}Variant<T extends ${typeName}Union['type']>(
+  union: ${typeName}Union,
+  type: T
+): union is Extract<${typeName}Union, { type: T }> {
+  return union.type === type;
 }`;
 }
 /**
  * Generate client integration with branded types
  */
 function generateClientBrandedTypeIntegration(_generatedClient, options) {
-    return `
-
-/**
- * Branded type integration for API client
- */
-
-/**
- * Type-safe API client with branded type validation
- */
-export class BrandedApiClient {
-  /**
-   * Validate and brand response data
-   */
-  static validateResponse<T, B extends T & { __brand: any }>(
-    data: T,
-    validator: (data: T) => B
-  ): B {
-    try {
-      return validator(data);
-    } catch (error) {
-      throw new Error(\`Response validation failed: \${error instanceof Error ? error.message : 'Unknown error'}\`);
-    }
-  }
-
-  /**
-   * Wrap request with branded type validation
-   */
-  static withBrandValidation<TRequest, TResponse, TBrandedResponse extends TResponse & { __brand: any }>(
-    requestFn: (data: TRequest) => Promise<TResponse>,
-    responseValidator: (data: TResponse) => TBrandedResponse
-  ) {
-    return async (data: TRequest): Promise<TBrandedResponse> => {
-      const response = await requestFn(data);
-      return this.validateResponse(response, responseValidator);
-    };
-  }
-}
-
-/**
- * Type-safe wrapper function
- */
-export function withBrandValidation<T extends (...args: any[]) => Promise<any>, R>(
-  fn: T,
-  validator: (result: Awaited<ReturnType<T>>) => R
-): (...args: Parameters<T>) => Promise<R> {
-  return async (...args: Parameters<T>): Promise<R> => {
-    const result = await fn(...args);
-    return validator(result);
-  };
-}
-
+    return `
+
+/**
+ * Branded type integration for API client
+ */
+
+/**
+ * Type-safe API client with branded type validation
+ */
+export class BrandedApiClient {
+  /**
+   * Validate and brand response data
+   */
+  static validateResponse<T, B extends T & { __brand: any }>(
+    data: T,
+    validator: (data: T) => B
+  ): B {
+    try {
+      return validator(data);
+    } catch (error) {
+      throw new Error(\`Response validation failed: \${error instanceof Error ? error.message : 'Unknown error'}\`);
+    }
+  }
+
+  /**
+   * Wrap request with branded type validation
+   */
+  static withBrandValidation<TRequest, TResponse, TBrandedResponse extends TResponse & { __brand: any }>(
+    requestFn: (data: TRequest) => Promise<TResponse>,
+    responseValidator: (data: TResponse) => TBrandedResponse
+  ) {
+    return async (data: TRequest): Promise<TBrandedResponse> => {
+      const response = await requestFn(data);
+      return this.validateResponse<TResponse, TBrandedResponse>(response, responseValidator);
+    };
+  }
+}
+
+/**
+ * Type-safe wrapper function
+ */
+export function withBrandValidation<T extends (...args: any[]) => Promise<any>, R>(
+  fn: T,
+  validator: (result: Awaited<ReturnType<T>>) => R
+): (...args: Parameters<T>) => Promise<R> {
+  return async (...args: Parameters<T>): Promise<R> => {
+    const result = await fn(...args);
+    return validator(result);
+  };
+}
+
 ${options.enablePhantomTypes ? generatePhantomApiClient() : ""}`;
 }
 /**
  * Generate phantom type API client integration
  */
 function generatePhantomApiClient() {
-    return `
-
-/**
- * API client with phantom authentication state
- */
-export class AuthenticatedApiClient {
-  private readonly isAuthenticated = true;
-
-  /**
-   * Execute authenticated request
-   */
-  async executeAuthenticatedRequest<T>(
-    request: () => Promise<T>
-  ): Promise<T> {
-    if (!this.isAuthenticated) {
-      throw new Error('Client is not authenticated');
-    }
-    return request();
-  }
-}
-
-export class UnauthenticatedApiClient {
-  private readonly isAuthenticated = false;
-
-  /**
-   * Execute public request
-   */
-  async executePublicRequest<T>(
-    request: () => Promise<T>
-  ): Promise<T> {
-    return request();
-  }
-
-  /**
-   * Authenticate and return authenticated client
-   */
-  async authenticate(credentials: { token: string }): Promise<AuthenticatedApiClient> {
-    // Authentication logic would go here
-    console.log('Authenticating with token:', credentials.token);
-    return new AuthenticatedApiClient();
-  }
+    return `
+
+/**
+ * API client with phantom authentication state
+ */
+export { BrandedApiClient as TypeSafeApiClient };
+
+export class AuthenticatedApiClient {
+  private readonly isAuthenticated = true;
+
+  /**
+   * Execute authenticated request
+   */
+  async executeAuthenticatedRequest<T>(
+    request: () => Promise<T>
+  ): Promise<T> {
+    if (!this.isAuthenticated) {
+      throw new Error('Client is not authenticated');
+    }
+    return request();
+  }
+}
+
+export class UnauthenticatedApiClient {
+
+  /**
+   * Execute public request
+   */
+  async executePublicRequest<T>(
+    request: () => Promise<T>
+  ): Promise<T> {
+    return request();
+  }
+
+  /**
+   * Authenticate and return authenticated client
+   */
+  async authenticate(credentials: { token: string }): Promise<AuthenticatedApiClient> {
+    if (!credentials.token) throw new Error('A token is required for client authentication state metadata');
+    return new AuthenticatedApiClient();
+  }
 }`;
 }
 // Export plugin for registration