archetype-engine 2.0.0

package/dist/src/templates/nextjs-drizzle-trpc/generators/validation.js

@@ -0,0 +1,248 @@
+"use strict";
+/**
+ * Zod Validation Schema Generator
+ *
+ * Generates Zod validation schemas for entity CRUD operations.
+ * Supports internationalized error messages via next-intl.
+ *
+ * Generated files:
+ * - schemas/{entity}.ts - Create and Update schemas with types
+ *
+ * Features:
+ * - Maps field types to Zod validators (z.string(), z.number(), etc.)
+ * - Generates validation rules from field config (min, max, email, url, regex)
+ * - Supports i18n error messages when multiple languages configured
+ * - Creates both static and i18n-aware schema factory functions
+ * - Exports TypeScript types derived from schemas
+ *
+ * @module generators/validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationGenerator = void 0;
+/**
+ * Generate Zod schema chain for a single field
+ *
+ * @param fieldName - Field name for error messages
+ * @param config - Field configuration with type and validations
+ * @param useI18n - Whether to use i18n translation function for messages
+ * @returns Zod schema chain as string (e.g., "z.string().email().min(1)")
+ */
+function generateFieldSchema(fieldName, config, useI18n) {
+    const parts = [];
+    const label = config.label || fieldName;
+    // Base type - handle enum fields specially with z.enum()
+    if (config.type === 'enum' && config.enumValues) {
+        const values = config.enumValues.map(v => `'${v}'`).join(', ');
+        parts.push(`z.enum([${values}])`);
+        // Optional (must come after base type)
+        if (!config.required) {
+            parts.push('.optional()');
+        }
+        // Default (must come after optional)
+        if (config.default !== undefined && !config.required) {
+            parts.push(`.default('${config.default}')`);
+        }
+        return parts.join('');
+    }
+    // Regular field types
+    switch (config.type) {
+        case 'text':
+            parts.push('z.string()');
+            break;
+        case 'number':
+            parts.push('z.number()');
+            break;
+        case 'boolean':
+            parts.push('z.boolean()');
+            break;
+        case 'date':
+            parts.push('z.string()');
+            break;
+    }
+    // Required check for text (must come before validations and optional)
+    if (config.required && config.type === 'text') {
+        if (useI18n) {
+            parts.push(`.min(1, { message: t('required', { field: '${label}' }) })`);
+        }
+        else {
+            parts.push(`.min(1, { message: '${label} is required' })`);
+        }
+    }
+    // Validations (must come before optional)
+    for (const validation of config.validations) {
+        parts.push(generateValidation(validation, label, useI18n));
+    }
+    // Optional (must come after validations)
+    if (!config.required) {
+        parts.push('.optional()');
+    }
+    // Default (must come after optional)
+    if (config.default !== undefined && !config.required) {
+        if (typeof config.default === 'string') {
+            parts.push(`.default('${config.default}')`);
+        }
+        else {
+            parts.push(`.default(${config.default})`);
+        }
+    }
+    return parts.join('');
+}
+/**
+ * Generate Zod validation method for a specific validation rule
+ *
+ * @param v - Validation rule from field config
+ * @param label - Field label for error messages
+ * @param useI18n - Whether to use i18n translation function
+ * @returns Zod method call as string (e.g., ".min(5, { message: ... })")
+ */
+function generateValidation(v, label, useI18n) {
+    const msg = (key, params = {}) => {
+        if (useI18n) {
+            const paramStr = Object.entries({ field: label, ...params })
+                .map(([k, val]) => {
+                if (typeof val === 'string')
+                    return `${k}: '${val}'`;
+                if (Array.isArray(val))
+                    return `${k}: '${val.join(', ')}'`;
+                return `${k}: ${val}`;
+            })
+                .join(', ');
+            return `{ message: t('${key}', { ${paramStr} }) }`;
+        }
+        // Static messages
+        const messages = {
+            minLength: `${label} must be at least ${params.min} characters`,
+            maxLength: `${label} must be at most ${params.max} characters`,
+            min: `${label} must be at least ${params.min}`,
+            max: `${label} must be at most ${params.max}`,
+            email: `Invalid email address`,
+            url: `Invalid URL`,
+            integer: `${label} must be a whole number`,
+            positive: `${label} must be positive`,
+            pattern: `${label} format is invalid`,
+            oneOf: `${label} must be one of: ${params.values?.join(', ')}`,
+        };
+        return `{ message: '${messages[key] || `Invalid ${label}`}' }`;
+    };
+    switch (v.type) {
+        case 'minLength': return `.min(${v.value}, ${msg('minLength', { min: v.value })})`;
+        case 'maxLength': return `.max(${v.value}, ${msg('maxLength', { max: v.value })})`;
+        case 'min': return `.min(${v.value}, ${msg('min', { min: v.value })})`;
+        case 'max': return `.max(${v.value}, ${msg('max', { max: v.value })})`;
+        case 'email': return `.email(${msg('email')})`;
+        case 'url': return `.url(${msg('url')})`;
+        case 'regex': return `.regex(/${v.value}/, ${msg('pattern')})`;
+        case 'integer': return `.int(${msg('integer')})`;
+        case 'positive': return `.positive(${msg('positive')})`;
+        case 'oneOf':
+            const values = v.value;
+            return `.refine(v => ${JSON.stringify(values)}.includes(v), ${msg('oneOf', { values })})`;
+        case 'trim': return '.trim()';
+        case 'lowercase': return '.toLowerCase()';
+        case 'uppercase': return '.toUpperCase()';
+        default: return '';
+    }
+}
+/**
+ * Generate complete validation schema file for an entity
+ *
+ * Creates both static schemas and i18n-aware factory functions when i18n is enabled.
+ *
+ * @param entity - Entity IR with fields and relations
+ * @param useI18n - Whether to generate i18n-aware schema factories
+ * @returns Complete schema file content as string
+ */
+function generateEntitySchema(entity, useI18n) {
+    const name = entity.name;
+    const lowerName = name.toLowerCase();
+    const staticFields = [];
+    for (const [fieldName, config] of Object.entries(entity.fields)) {
+        // Skip computed fields - they're derived at runtime, not user input
+        if (config.type === 'computed')
+            continue;
+        staticFields.push(`    ${fieldName}: ${generateFieldSchema(fieldName, config, false)},`);
+    }
+    for (const [relName, rel] of Object.entries(entity.relations)) {
+        if (rel.type === 'hasOne') {
+            const fkField = rel.field || `${relName}Id`;
+            // Skip if this field was already defined in entity.fields
+            if (entity.fields[fkField])
+                continue;
+            // Match required status from relation - if relation is optional, FK is optional
+            const zodType = rel.optional ? 'z.string().optional()' : 'z.string()';
+            staticFields.push(`    ${fkField}: ${zodType},`);
+        }
+    }
+    if (useI18n) {
+        const i18nFields = [];
+        for (const [fieldName, config] of Object.entries(entity.fields)) {
+            // Skip computed fields - they're derived at runtime, not user input
+            if (config.type === 'computed')
+                continue;
+            i18nFields.push(`    ${fieldName}: ${generateFieldSchema(fieldName, config, true)},`);
+        }
+        for (const [relName, rel] of Object.entries(entity.relations)) {
+            if (rel.type === 'hasOne') {
+                const fkField = rel.field || `${relName}Id`;
+                // Skip if this field was already defined in entity.fields
+                if (entity.fields[fkField])
+                    continue;
+                // Match required status from relation - if relation is optional, FK is optional
+                const zodType = rel.optional ? 'z.string().optional()' : 'z.string()';
+                i18nFields.push(`    ${fkField}: ${zodType},`);
+            }
+        }
+        return `// Auto-generated Zod schema for ${name}
+// Do not edit manually - regenerate with: npx archetype generate
+
+import { z } from 'zod'
+import { useTranslations } from 'next-intl'
+
+type TranslationFn = ReturnType<typeof useTranslations<'validation'>>
+
+export const ${lowerName}CreateSchema = z.object({
+${staticFields.join('\n')}
+})
+
+export const ${lowerName}UpdateSchema = ${lowerName}CreateSchema.partial()
+
+export function ${lowerName}CreateSchemaI18n(t: TranslationFn) {
+  return z.object({
+${i18nFields.join('\n')}
+  })
+}
+
+export function ${lowerName}UpdateSchemaI18n(t: TranslationFn) {
+  return ${lowerName}CreateSchemaI18n(t).partial()
+}
+
+export type ${name}Create = z.input<typeof ${lowerName}CreateSchema>
+export type ${name}Update = z.input<typeof ${lowerName}UpdateSchema>
+`;
+    }
+    return `// Auto-generated Zod schema for ${name}
+// Do not edit manually - regenerate with: npx archetype generate
+
+import { z } from 'zod'
+
+export const ${lowerName}CreateSchema = z.object({
+${staticFields.join('\n')}
+})
+
+export const ${lowerName}UpdateSchema = ${lowerName}CreateSchema.partial()
+
+export type ${name}Create = z.input<typeof ${lowerName}CreateSchema>
+export type ${name}Update = z.input<typeof ${lowerName}UpdateSchema>
+`;
+}
+exports.validationGenerator = {
+    name: 'zod-schemas',
+    description: 'Generate Zod validation schemas',
+    generate(manifest, ctx) {
+        const useI18n = manifest.i18n.languages.length > 1;
+        return manifest.entities.map(entity => ({
+            path: `schemas/${entity.name.toLowerCase()}.ts`,
+            content: generateEntitySchema(entity, useI18n),
+        }));
+    },
+};

package/dist/src/templates/nextjs-drizzle-trpc/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Next.js + Drizzle + tRPC Template
+ *
+ * Full-stack template for Next.js applications with:
+ * - Drizzle ORM for database access
+ * - tRPC for type-safe API routes
+ * - Zod for runtime validation
+ * - React Hook Form integration for forms
+ *
+ * Supports both database-backed and external API-backed entities.
+ * Can run in full mode (with database) or headless mode (API-only).
+ *
+ * @module templates/nextjs-drizzle-trpc
+ */
+import type { Template } from '../../template/types';
+/**
+ * Template definition for Next.js + Drizzle + tRPC stack
+ *
+ * Generators run in order, with some conditionally skipped:
+ * 1. schemaGenerator - Drizzle tables (skipped in headless mode)
+ * 2. authGenerator - Auth.js tables (only if auth.enabled)
+ * 3. validationGenerator - Zod schemas (always runs)
+ * 4. serviceGenerator - API client (only for external entities)
+ * 5. apiGenerator - tRPC routers (adapts to source type)
+ * 6. hooksGenerator - React hooks (always runs)
+ * 7. i18nGenerator - Translation files (only if i18n configured)
+ */
+export declare const template: Template;
+export default template;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/templates/nextjs-drizzle-trpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/nextjs-drizzle-trpc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAUpD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,EAAE,QAgCtB,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/src/templates/nextjs-drizzle-trpc/index.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Next.js + Drizzle + tRPC Template
+ *
+ * Full-stack template for Next.js applications with:
+ * - Drizzle ORM for database access
+ * - tRPC for type-safe API routes
+ * - Zod for runtime validation
+ * - React Hook Form integration for forms
+ *
+ * Supports both database-backed and external API-backed entities.
+ * Can run in full mode (with database) or headless mode (API-only).
+ *
+ * @module templates/nextjs-drizzle-trpc
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.template = void 0;
+const schema_1 = require("./generators/schema");
+const auth_1 = require("./generators/auth");
+const validation_1 = require("./generators/validation");
+const service_1 = require("./generators/service");
+const api_1 = require("./generators/api");
+const hooks_1 = require("./generators/hooks");
+const crud_hooks_1 = require("./generators/crud-hooks");
+const i18n_1 = require("./generators/i18n");
+/**
+ * Template definition for Next.js + Drizzle + tRPC stack
+ *
+ * Generators run in order, with some conditionally skipped:
+ * 1. schemaGenerator - Drizzle tables (skipped in headless mode)
+ * 2. authGenerator - Auth.js tables (only if auth.enabled)
+ * 3. validationGenerator - Zod schemas (always runs)
+ * 4. serviceGenerator - API client (only for external entities)
+ * 5. apiGenerator - tRPC routers (adapts to source type)
+ * 6. hooksGenerator - React hooks (always runs)
+ * 7. i18nGenerator - Translation files (only if i18n configured)
+ */
+exports.template = {
+    meta: {
+        id: 'nextjs-drizzle-trpc',
+        name: 'Next.js + Drizzle + tRPC',
+        description: 'Full-stack Next.js with Drizzle ORM, tRPC API, and React hooks. Supports headless mode with external APIs.',
+        framework: 'nextjs',
+        stack: {
+            database: 'drizzle',
+            validation: 'zod',
+            api: 'trpc',
+            ui: 'react',
+        },
+    },
+    defaultConfig: {
+        outputDir: 'generated',
+        importAliases: {
+            '@/': 'src/',
+            '@/server': 'src/server',
+            '@/lib': 'src/lib',
+            '@/generated': 'generated',
+        },
+    },
+    generators: [
+        schema_1.schemaGenerator, // Skipped in headless mode
+        auth_1.authGenerator, // Only if auth enabled
+        validation_1.validationGenerator, // Always runs
+        service_1.serviceGenerator, // Only for external entities
+        api_1.apiGenerator, // Adapts to source type + auth
+        hooks_1.hooksGenerator, // Always runs
+        crud_hooks_1.crudHooksGenerator, // Only if hooks enabled
+        i18n_1.i18nGenerator, // Only if i18n enabled
+    ],
+};
+exports.default = exports.template;

package/dist/src/validation/index.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Validation Module for AI Agent Input
+ *
+ * Provides structured validation with error codes that AI agents can parse
+ * and use to fix their output.
+ *
+ * @module validation
+ */
+import { ManifestJSON } from '../json/types';
+/**
+ * Validation error with structured information for AI parsing
+ */
+export interface ValidationError {
+    /** Error code for programmatic handling */
+    code: string;
+    /** JSON path to the error location */
+    path: string;
+    /** Human-readable error message */
+    message: string;
+    /** Suggestion for how to fix the error */
+    suggestion?: string;
+}
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+    /** Whether the manifest is valid */
+    valid: boolean;
+    /** Validation errors (blocking) */
+    errors: ValidationError[];
+    /** Validation warnings (non-blocking) */
+    warnings: ValidationError[];
+}
+export declare const ValidationCodes: {
+    readonly INVALID_ENTITY_NAME: "INVALID_ENTITY_NAME";
+    readonly DUPLICATE_ENTITY: "DUPLICATE_ENTITY";
+    readonly MISSING_ENTITY_FIELDS: "MISSING_ENTITY_FIELDS";
+    readonly INVALID_FIELD_TYPE: "INVALID_FIELD_TYPE";
+    readonly INVALID_FIELD_NAME: "INVALID_FIELD_NAME";
+    readonly RELATION_TARGET_NOT_FOUND: "RELATION_TARGET_NOT_FOUND";
+    readonly INVALID_RELATION_TYPE: "INVALID_RELATION_TYPE";
+    readonly DATABASE_REQUIRED: "DATABASE_REQUIRED";
+    readonly INVALID_DATABASE_TYPE: "INVALID_DATABASE_TYPE";
+    readonly SQLITE_REQUIRES_FILE: "SQLITE_REQUIRES_FILE";
+    readonly POSTGRES_REQUIRES_URL: "POSTGRES_REQUIRES_URL";
+    readonly AUTH_REQUIRED_FOR_PROTECTED: "AUTH_REQUIRED_FOR_PROTECTED";
+    readonly INVALID_PROVIDER: "INVALID_PROVIDER";
+    readonly INVALID_MODE: "INVALID_MODE";
+    readonly INVALID_PROTECTED_VALUE: "INVALID_PROTECTED_VALUE";
+    readonly EXTERNAL_SOURCE_INVALID: "EXTERNAL_SOURCE_INVALID";
+};
+/**
+ * Validate a JSON manifest
+ *
+ * @param manifest - JSON manifest to validate
+ * @returns Validation result with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const result = validateManifest({
+ *   entities: [{ name: 'User', fields: { email: { type: 'text' } } }],
+ *   database: { type: 'sqlite', file: './app.db' }
+ * })
+ *
+ * if (!result.valid) {
+ *   console.log('Errors:', result.errors)
+ * }
+ * ```
+ */
+export declare function validateManifest(manifest: ManifestJSON): ValidationResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/validation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/validation/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAuC,MAAM,eAAe,CAAA;AAEjF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAA;IACZ,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAA;IACZ,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,KAAK,EAAE,OAAO,CAAA;IACd,mCAAmC;IACnC,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,yCAAyC;IACzC,QAAQ,EAAE,eAAe,EAAE,CAAA;CAC5B;AAGD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAgClB,CAAA;AA6PV;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,YAAY,GAAG,gBAAgB,CA2DzE"}