schemantic 0.1.0

package/dist/plugins/branded-types.js

@@ -0,0 +1,568 @@
+"use strict";
+/**
+ * Advanced Branded Types Plugin
+ *
+ * Implements sophisticated branded types for compile-time safety guarantees,
+ * phantom type parameters for state management, and discriminated unions with
+ * runtime type guards for enhanced type system capabilities.
+ *
+ * Key Features:
+ * - Branded types for compile-time safety (prevents primitive obsession)
+ * - Phantom type parameters for authentication state management
+ * - Discriminated unions with exhaustive type checking
+ * - Runtime type guards with brand preservation
+ * - Type-level computations for advanced validations
+ * - Nominal typing simulation in TypeScript's structural system
+ *
+ * Architecture:
+ * - Zero-runtime-cost type safety through brands
+ * - Compile-time state tracking via phantom types
+ * - Type-level programming for validation pipelines
+ * - Integration with existing validation systems
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.brandedTypesPlugin = void 0;
+const schema_1 = require("../types/schema");
+/**
+ * Advanced Branded Types Plugin Implementation
+ */
+exports.brandedTypesPlugin = {
+    name: "branded-types",
+    version: "2.0.0",
+    description: "Advanced branded types with phantom parameters and type-level safety guarantees",
+    /**
+     * Transform schema to include brand metadata
+     */
+    transformSchema: (schema, context) => {
+        const options = getPluginOptions(context);
+        if (!options.enabled) {
+            return schema;
+        }
+        if ((0, schema_1.isOpenAPISchemaObject)(schema)) {
+            const extendedSchema = schema;
+            // Add brand metadata
+            extendedSchema._brandMetadata = {
+                shouldBrand: shouldGenerateBrand(schema),
+                brandType: determineBrandType(schema),
+                validationConstraints: extractValidationConstraints(schema),
+            };
+            // Process nested properties recursively
+            if (schema.properties) {
+                for (const [propName, propSchema] of Object.entries(schema.properties)) {
+                    if (typeof propSchema === "object" && propSchema !== null) {
+                        schema.properties[propName] = exports.brandedTypesPlugin.transformSchema(propSchema, context);
+                    }
+                }
+            }
+        }
+        return schema;
+    },
+    /**
+     * Enhance type generation with branded types
+     */
+    afterTypeGeneration: async (typeName, generatedType, context) => {
+        const options = getPluginOptions(context);
+        if (!options.enabled || !generatedType.isInterface) {
+            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`);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`Branded types plugin afterTypeGeneration failed for ${typeName}:`, error);
+        }
+    },
+    /**
+     * Enhance API client with branded type integration
+     */
+    afterClientGeneration: async (generatedClient, context) => {
+        const options = getPluginOptions(context);
+        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");
+                }
+            }
+        }
+        catch (error) {
+            console.warn("Branded types plugin afterClientGeneration failed:", error);
+        }
+    },
+};
+/**
+ * Get plugin options from generation context
+ */
+function getPluginOptions(context) {
+    const pluginConfig = context?.config?.plugins?.find((p) => p.name === "branded-types");
+    return {
+        enabled: true,
+        enablePhantomTypes: true,
+        enableRuntimeGuards: true,
+        enableDiscriminatedUnions: true,
+        enableTypeLevelValidations: false,
+        brandNamingConvention: "prefix",
+        brandIdentifier: "Brand",
+        enableAssertionFunctions: true,
+        enableOpaqueTypes: true,
+        enableTypePredicates: true,
+        ...(pluginConfig?.options || {}),
+    };
+}
+/**
+ * Determine if a schema should generate a branded type
+ */
+function shouldGenerateBrand(schema) {
+    // Generate brands for types with validation constraints or specific patterns
+    return !!(schema.pattern ||
+        schema.format ||
+        schema.minimum !== undefined ||
+        schema.maximum !== undefined ||
+        schema.minLength !== undefined ||
+        schema.maxLength !== undefined ||
+        schema.enum ||
+        (schema.type === "string" &&
+            (schema.description?.includes("id") ||
+                schema.description?.includes("Id"))));
+}
+/**
+ * Determine the type of brand to generate
+ */
+function determineBrandType(schema) {
+    if (schema.format) {
+        return `${schema.format}Brand`;
+    }
+    if (schema.pattern) {
+        return "PatternBrand";
+    }
+    if (schema.minimum !== undefined || schema.maximum !== undefined) {
+        return "NumericBrand";
+    }
+    if (schema.enum) {
+        return "EnumBrand";
+    }
+    return "DefaultBrand";
+}
+/**
+ * Extract validation constraints from schema
+ */
+function extractValidationConstraints(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}`);
+    }
+    if (schema.format) {
+        constraints.push(`format:${schema.format}`);
+    }
+    return constraints;
+}
+/**
+ * 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);
+}
+/**
+ * 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)
+        : ""}`;
+}
+/**
+ * Generate advanced branded type with validation constraints
+ */
+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)
+        : ""}`;
+}
+/**
+ * Generate validation code based on schema constraints
+ */
+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  ");
+}
+/**
+ * Generate constraint types for the brand
+ */
+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("; ");
+}
+/**
+ * Generate opaque type helpers
+ */
+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};
+}`;
+}
+/**
+ * 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
+}`;
+}
+/**
+ * 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;
+}`;
+}
+/**
+ * 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);
+  };
+}
+
+${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();
+  }
+}`;
+}
+// Export plugin for registration
+exports.default = exports.brandedTypesPlugin;
+//# sourceMappingURL=branded-types.js.map

package/dist/plugins/branded-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"branded-types.js","sourceRoot":"","sources":["../../src/plugins/branded-types.ts"],"names":[],"mappings":"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"}

package/dist/plugins/builtin.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Built-in plugins for common transformations and enhancements
+ * Provides standard plugins that can be used out of the box
+ */
+import { SchemanticPlugin } from "../types/core";
+/**
+ * Built-in plugin for adding JSDoc comments
+ */
+export declare const jsdocPlugin: SchemanticPlugin;
+/**
+ * Built-in plugin for adding validation decorators
+ */
+export declare const validationPlugin: SchemanticPlugin;
+/**
+ * Built-in plugin for adding React hooks generation
+ */
+export declare const reactHooksPlugin: SchemanticPlugin;
+/**
+ * Built-in plugin for adding TypeScript strict mode enhancements
+ */
+export declare const strictModePlugin: SchemanticPlugin;
+/**
+ * Get all built-in plugins (including advanced plugins)
+ */
+export declare function getBuiltinPlugins(): SchemanticPlugin[];
+/**
+ * Get basic built-in plugins only
+ */
+export declare function getBasicBuiltinPlugins(): SchemanticPlugin[];
+/**
+ * Get advanced built-in plugins only
+ */
+export declare function getAdvancedBuiltinPlugins(): SchemanticPlugin[];
+/**
+ * Get built-in plugin by name
+ */
+export declare function getBuiltinPlugin(name: string): SchemanticPlugin | undefined;
+//# sourceMappingURL=builtin.d.ts.map

package/dist/plugins/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/plugins/builtin.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,gBAAgB,EAIjB,MAAM,eAAe,CAAC;AAcvB;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,gBA+CzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAuF9B,CAAC;AAgEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAwB9B,CAAC;AAqBF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAqD9B,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,gBAAgB,EAAE,CActD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,EAAE,CAE3D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,gBAAgB,EAAE,CAO9D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE3E"}