archetype-engine 2.0.0

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

@@ -0,0 +1,270 @@
+"use strict";
+/**
+ * Drizzle ORM Schema Generator
+ *
+ * Generates database table definitions for Drizzle ORM from entity definitions.
+ * Supports SQLite, PostgreSQL, and MySQL databases.
+ *
+ * Generated files:
+ * - db/schema.ts - All entity table definitions and junction tables
+ *
+ * Features:
+ * - Maps field types to appropriate database column types
+ * - Handles required/optional fields with notNull()
+ * - Creates foreign key references for hasOne relations
+ * - Generates junction tables for belongsToMany relations
+ * - Adds timestamp fields (createdAt, updatedAt) when behaviors.timestamps is true
+ * - Adds deletedAt field when behaviors.softDelete is true
+ *
+ * @module generators/schema
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaGenerator = void 0;
+/**
+ * Map entity field type to Drizzle column type
+ *
+ * @param config - Field configuration from entity definition
+ * @param isSqlite - Whether target database is SQLite
+ * @returns Drizzle column type name
+ */
+function mapFieldType(config, isSqlite) {
+    switch (config.type) {
+        case 'text': return 'text';
+        case 'number': return 'integer';
+        case 'boolean': return isSqlite ? 'integer' : 'boolean';
+        case 'date': return 'text';
+        case 'enum': return 'text'; // Enum uses text for SQLite, pgEnum for PG (handled separately)
+        default: return 'text';
+    }
+}
+/**
+ * Generate enum type name from field name
+ */
+function getEnumTypeName(entityName, fieldName) {
+    return `${entityName.toLowerCase()}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Enum`;
+}
+/**
+ * Collect all enum fields from entities and generate pgEnum definitions
+ */
+function generateEnumDefinitions(manifest) {
+    const enums = [];
+    const generated = new Set();
+    for (const entity of manifest.entities) {
+        for (const [fieldName, config] of Object.entries(entity.fields)) {
+            if (config.type === 'enum' && config.enumValues) {
+                const enumName = config.enumName || getEnumTypeName(entity.name, fieldName);
+                if (!generated.has(enumName)) {
+                    generated.add(enumName);
+                    const values = config.enumValues.map(v => `'${v}'`).join(', ');
+                    enums.push(`export const ${enumName} = pgEnum('${enumName}', [${values}])`);
+                }
+            }
+        }
+    }
+    return enums.join('\n');
+}
+/**
+ * Generate a single field definition line for the schema
+ *
+ * @param fieldName - Name of the field in the entity
+ * @param config - Field configuration with type, validations, etc.
+ * @param isSqlite - Whether target database is SQLite
+ * @param ctx - Generator context with naming utilities
+ * @param entityName - Entity name for enum type naming
+ * @returns Drizzle field definition code (e.g., "email: text('email').notNull().unique(),")
+ */
+function generateFieldDefinition(fieldName, config, isSqlite, ctx, entityName) {
+    const columnName = ctx.naming.getColumnName(fieldName);
+    const parts = [];
+    // Handle enum fields specially
+    if (config.type === 'enum' && config.enumValues) {
+        if (isSqlite) {
+            // SQLite: use text column (validation enforced by Zod)
+            parts.push(`text('${columnName}')`);
+        }
+        else {
+            // PostgreSQL: use pgEnum reference
+            const enumName = config.enumName || (entityName ? getEnumTypeName(entityName, fieldName) : `${fieldName}Enum`);
+            parts.push(`${enumName}('${columnName}')`);
+        }
+    }
+    else if (config.type === 'boolean' && isSqlite) {
+        parts.push(`integer('${columnName}', { mode: 'boolean' })`);
+    }
+    else {
+        const type = mapFieldType(config, isSqlite);
+        parts.push(`${type}('${columnName}')`);
+    }
+    if (config.required)
+        parts.push('.notNull()');
+    if (config.unique)
+        parts.push('.unique()');
+    if (config.default !== undefined) {
+        if (typeof config.default === 'string') {
+            parts.push(`.default('${config.default}')`);
+        }
+        else {
+            parts.push(`.default(${config.default})`);
+        }
+    }
+    return `  ${fieldName}: ${parts.join('')},`;
+}
+/**
+ * Generate complete table definition for an entity
+ *
+ * @param entity - Compiled entity IR with fields, relations, and behaviors
+ * @param isSqlite - Whether target database is SQLite
+ * @param ctx - Generator context with naming utilities
+ * @returns Complete Drizzle table definition code
+ */
+function generateEntity(entity, isSqlite, ctx) {
+    const tableName = ctx.naming.getTableName(entity.name);
+    const tableFunc = isSqlite ? 'sqliteTable' : 'pgTable';
+    const lines = [];
+    lines.push(`export const ${tableName} = ${tableFunc}('${tableName}', {`);
+    lines.push(`  id: text('id').primaryKey(),`);
+    // User-defined fields (skip computed fields - they're not stored in DB)
+    for (const [fieldName, config] of Object.entries(entity.fields)) {
+        if (config.type === 'computed')
+            continue;
+        lines.push(generateFieldDefinition(fieldName, config, isSqlite, ctx, entity.name));
+    }
+    // Foreign keys for hasOne relations (skip if field already exists)
+    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;
+            // Skip self-referential relations - they cause TypeScript issues with inline references
+            if (rel.entity === entity.name) {
+                const fkColumn = ctx.naming.getColumnName(fkField);
+                lines.push(`  ${fkField}: text('${fkColumn}'), // Self-reference handled via relations`);
+                continue;
+            }
+            const fkColumn = ctx.naming.getColumnName(fkField);
+            const targetTable = ctx.naming.getTableName(rel.entity);
+            const notNull = rel.optional ? '' : '.notNull()';
+            lines.push(`  ${fkField}: text('${fkColumn}').references(() => ${targetTable}.id)${notNull},`);
+        }
+    }
+    // Timestamps
+    if (entity.behaviors.timestamps) {
+        lines.push(`  createdAt: text('created_at').notNull(),`);
+        lines.push(`  updatedAt: text('updated_at').notNull(),`);
+    }
+    // Soft delete
+    if (entity.behaviors.softDelete) {
+        lines.push(`  deletedAt: text('deleted_at'),`);
+    }
+    lines.push('})');
+    return lines.join('\n');
+}
+/**
+ * Generate pivot fields for junction tables
+ *
+ * @param fields - Pivot field configurations
+ * @param isSqlite - Whether target database is SQLite
+ * @param ctx - Generator context
+ * @returns Array of field definition lines
+ */
+function generatePivotFields(fields, isSqlite, ctx) {
+    if (!fields)
+        return [];
+    return Object.entries(fields).map(([fieldName, config]) => generateFieldDefinition(fieldName, config, isSqlite, ctx));
+}
+/**
+ * Generate junction tables for many-to-many relations
+ *
+ * Creates tables for belongsToMany relations. Handles both regular many-to-many
+ * and self-referential relations (e.g., User following User).
+ * Supports pivot fields for additional data on the relation.
+ *
+ * @param manifest - Compiled manifest with all entities
+ * @param isSqlite - Whether target database is SQLite
+ * @param ctx - Generator context with naming utilities
+ * @returns Junction table definitions code
+ */
+function generateJunctionTables(manifest, isSqlite, ctx) {
+    const tableFunc = isSqlite ? 'sqliteTable' : 'pgTable';
+    const tables = [];
+    const generated = new Set();
+    for (const entity of manifest.entities) {
+        for (const [relName, rel] of Object.entries(entity.relations)) {
+            if (rel.type === 'belongsToMany') {
+                const table1 = ctx.naming.getTableName(entity.name);
+                const table2 = ctx.naming.getTableName(rel.entity);
+                // Generate pivot fields if defined
+                const pivotFields = generatePivotFields(rel.pivot?.fields, isSqlite, ctx);
+                const pivotFieldsStr = pivotFields.length > 0 ? '\n' + pivotFields.join('\n') : '';
+                if (entity.name === rel.entity) {
+                    // Self-referential
+                    const junctionName = rel.pivot?.table || `${entity.name.toLowerCase()}_${ctx.naming.toSnakeCase(relName)}`;
+                    if (!generated.has(junctionName)) {
+                        generated.add(junctionName);
+                        tables.push(`
+export const ${ctx.naming.toCamelCase(junctionName)} = ${tableFunc}('${junctionName}', {
+  sourceId: text('source_id').notNull().references(() => ${table1}.id),
+  targetId: text('target_id').notNull().references(() => ${table2}.id),${pivotFieldsStr}
+})`);
+                    }
+                }
+                else if (entity.name < rel.entity) {
+                    // Custom table name from pivot config or default
+                    const junctionName = rel.pivot?.table || `${entity.name.toLowerCase()}_${rel.entity.toLowerCase()}`;
+                    if (!generated.has(junctionName)) {
+                        generated.add(junctionName);
+                        tables.push(`
+export const ${ctx.naming.toCamelCase(junctionName)} = ${tableFunc}('${junctionName}', {
+  ${entity.name.toLowerCase()}Id: text('${ctx.naming.toSnakeCase(entity.name)}_id').notNull().references(() => ${table1}.id),
+  ${rel.entity.toLowerCase()}Id: text('${ctx.naming.toSnakeCase(rel.entity)}_id').notNull().references(() => ${table2}.id),${pivotFieldsStr}
+})`);
+                    }
+                }
+            }
+        }
+    }
+    return tables.join('\n');
+}
+/**
+ * Check if manifest has any enum fields
+ */
+function hasEnumFields(manifest) {
+    return manifest.entities.some(entity => Object.values(entity.fields).some(f => f.type === 'enum'));
+}
+exports.schemaGenerator = {
+    name: 'drizzle-schema',
+    description: 'Generate Drizzle ORM schema',
+    generate(manifest, ctx) {
+        const isSqlite = ctx.database.isSqlite;
+        const hasEnums = hasEnumFields(manifest);
+        // Build imports based on database type and features used
+        let imports;
+        if (isSqlite) {
+            imports = `import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'`;
+        }
+        else {
+            const pgImports = ['pgTable', 'text', 'integer', 'boolean', 'timestamp'];
+            if (hasEnums)
+                pgImports.push('pgEnum');
+            imports = `import { ${pgImports.join(', ')} } from 'drizzle-orm/pg-core'`;
+        }
+        // Generate enum definitions for PostgreSQL
+        const enumDefs = !isSqlite && hasEnums ? generateEnumDefinitions(manifest) + '\n\n' : '';
+        const entities = manifest.entities
+            .map(entity => generateEntity(entity, isSqlite, ctx))
+            .join('\n\n');
+        const junctionTables = generateJunctionTables(manifest, isSqlite, ctx);
+        return {
+            path: 'db/schema.ts',
+            content: `// Auto-generated Drizzle schema
+// Do not edit manually - regenerate with: npx archetype generate
+
+${imports}
+
+${enumDefs}${entities}
+${junctionTables}
+`,
+        };
+    },
+};

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

@@ -0,0 +1,23 @@
+/**
+ * Service Layer Generator
+ *
+ * Generates service modules for entities backed by external APIs.
+ * Only runs when entities have external source configuration.
+ *
+ * Generated files:
+ * - services/apiClient.ts - Reusable HTTP client with typed methods
+ * - services/{entity}Service.ts - CRUD operations for each external entity
+ * - services/index.ts - Barrel export of all services
+ *
+ * Features:
+ * - Environment variable support for base URLs (env:VARIABLE_NAME syntax)
+ * - RESTful endpoint pattern support (GET /products/:id)
+ * - Typed request/response handling
+ * - Error handling with HTTP status codes
+ * - AbortSignal support for request cancellation
+ *
+ * @module generators/service
+ */
+import type { Generator } from '../../../template/types';
+export declare const serviceGenerator: Generator;
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../src/templates/nextjs-drizzle-trpc/generators/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,yBAAyB,CAAA;AA+QvE,eAAO,MAAM,gBAAgB,EAAE,SAoC9B,CAAA"}

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

@@ -0,0 +1,304 @@
+"use strict";
+/**
+ * Service Layer Generator
+ *
+ * Generates service modules for entities backed by external APIs.
+ * Only runs when entities have external source configuration.
+ *
+ * Generated files:
+ * - services/apiClient.ts - Reusable HTTP client with typed methods
+ * - services/{entity}Service.ts - CRUD operations for each external entity
+ * - services/index.ts - Barrel export of all services
+ *
+ * Features:
+ * - Environment variable support for base URLs (env:VARIABLE_NAME syntax)
+ * - RESTful endpoint pattern support (GET /products/:id)
+ * - Typed request/response handling
+ * - Error handling with HTTP status codes
+ * - AbortSignal support for request cancellation
+ *
+ * @module generators/service
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceGenerator = void 0;
+const source_1 = require("../../../source");
+/**
+ * Parse environment variable syntax in base URL
+ *
+ * Converts 'env:VARIABLE_NAME' to 'process.env.VARIABLE_NAME' for runtime resolution.
+ * Regular URLs are returned as string literals.
+ *
+ * @param baseUrl - Base URL string, may contain env: prefix
+ * @returns JavaScript expression for the URL
+ */
+function parseEnvUrl(baseUrl) {
+    if (baseUrl.startsWith('env:')) {
+        const varName = baseUrl.slice(4);
+        return `process.env.${varName}`;
+    }
+    return `'${baseUrl}'`;
+}
+/**
+ * Parse endpoint string into HTTP method and path
+ *
+ * @example
+ * parseEndpoint('GET /products/:id') // { method: 'GET', path: '/products/:id' }
+ * parseEndpoint('/products')         // { method: 'GET', path: '/products' }
+ *
+ * @param endpoint - Endpoint string with optional method prefix
+ * @returns Object with method and path
+ */
+function parseEndpoint(endpoint) {
+    const parts = endpoint.split(' ');
+    if (parts.length === 2) {
+        return { method: parts[0], path: parts[1] };
+    }
+    // Default to GET if no method specified
+    return { method: 'GET', path: endpoint };
+}
+/**
+ * Generate the shared API client module
+ *
+ * Creates a reusable HTTP client with typed methods for GET, POST, PUT, DELETE.
+ * Includes URL building with query parameters and error handling.
+ *
+ * @returns Generated file for apiClient.ts
+ */
+function generateApiClient() {
+    return {
+        path: 'services/apiClient.ts',
+        content: `// Auto-generated API client
+// Do not edit manually - regenerate with: npx archetype generate
+
+export interface RequestConfig {
+  headers?: Record<string, string>
+  params?: Record<string, unknown>
+  signal?: AbortSignal
+}
+
+export interface ApiResponse<T> {
+  data: T
+  status: number
+}
+
+class ApiClient {
+  private defaultHeaders: Record<string, string>
+
+  constructor(headers: Record<string, string> = {}) {
+    this.defaultHeaders = headers
+  }
+
+  private buildUrl(baseUrl: string, path: string, params?: Record<string, unknown>): string {
+    const url = new URL(path, baseUrl)
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+          url.searchParams.set(key, String(value))
+        }
+      })
+    }
+    return url.toString()
+  }
+
+  async get<T>(baseUrl: string, path: string, config?: RequestConfig): Promise<ApiResponse<T>> {
+    const url = this.buildUrl(baseUrl, path, config?.params)
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { ...this.defaultHeaders, ...config?.headers },
+      signal: config?.signal,
+    })
+    if (!response.ok) {
+      throw new Error(\`HTTP error \${response.status}: \${response.statusText}\`)
+    }
+    return { data: await response.json(), status: response.status }
+  }
+
+  async post<T>(baseUrl: string, path: string, body: unknown, config?: RequestConfig): Promise<ApiResponse<T>> {
+    const response = await fetch(\`\${baseUrl}\${path}\`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.defaultHeaders,
+        ...config?.headers,
+      },
+      body: JSON.stringify(body),
+      signal: config?.signal,
+    })
+    if (!response.ok) {
+      throw new Error(\`HTTP error \${response.status}: \${response.statusText}\`)
+    }
+    return { data: await response.json(), status: response.status }
+  }
+
+  async put<T>(baseUrl: string, path: string, body: unknown, config?: RequestConfig): Promise<ApiResponse<T>> {
+    const response = await fetch(\`\${baseUrl}\${path}\`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json',
+        ...this.defaultHeaders,
+        ...config?.headers,
+      },
+      body: JSON.stringify(body),
+      signal: config?.signal,
+    })
+    if (!response.ok) {
+      throw new Error(\`HTTP error \${response.status}: \${response.statusText}\`)
+    }
+    return { data: await response.json(), status: response.status }
+  }
+
+  async delete<T>(baseUrl: string, path: string, config?: RequestConfig): Promise<ApiResponse<T>> {
+    const response = await fetch(\`\${baseUrl}\${path}\`, {
+      method: 'DELETE',
+      headers: { ...this.defaultHeaders, ...config?.headers },
+      signal: config?.signal,
+    })
+    if (!response.ok) {
+      throw new Error(\`HTTP error \${response.status}: \${response.statusText}\`)
+    }
+    return { data: await response.json(), status: response.status }
+  }
+}
+
+export const apiClient = new ApiClient()
+`,
+    };
+}
+/**
+ * Generate service module for a single entity with external API source
+ *
+ * @param entity - Entity IR with source configuration
+ * @param source - External source config with base URL and endpoints
+ * @param ctx - Generator context
+ * @returns Generated file for {entity}Service.ts
+ */
+function generateEntityService(entity, source, ctx) {
+    const name = entity.name;
+    const lowerName = name.toLowerCase();
+    const endpoints = (0, source_1.resolveEndpoints)(name, source);
+    const listEndpoint = parseEndpoint(endpoints.list);
+    const getEndpoint = parseEndpoint(endpoints.get);
+    const createEndpoint = parseEndpoint(endpoints.create);
+    const updateEndpoint = parseEndpoint(endpoints.update);
+    const deleteEndpoint = parseEndpoint(endpoints.delete);
+    const baseUrlCode = parseEnvUrl(source.baseUrl);
+    // Generate path with parameter substitution
+    const pathWithId = (path) => {
+        // Replace :id with ${id}
+        return path.replace(/:([a-zA-Z_]+)/g, '${$1}');
+    };
+    return {
+        path: `services/${lowerName}Service.ts`,
+        content: `// Auto-generated service for ${name}
+// Do not edit manually - regenerate with: npx archetype generate
+
+import { apiClient } from './apiClient'
+import type { ${name}Create, ${name}Update } from '../schemas/${lowerName}'
+
+const BASE_URL = ${baseUrlCode}!
+
+export interface ${name}ListParams {
+  page?: number
+  limit?: number
+  [key: string]: unknown
+}
+
+export const ${lowerName}Service = {
+  /**
+   * List all ${name}s
+   */
+  async list(params?: ${name}ListParams) {
+    const response = await apiClient.get<${name}[]>(BASE_URL, '${listEndpoint.path}', { params })
+    return response.data
+  },
+
+  /**
+   * Get a single ${name} by ID
+   */
+  async get(id: string) {
+    const response = await apiClient.get<${name}>(BASE_URL, \`${pathWithId(getEndpoint.path)}\`)
+    return response.data
+  },
+
+  /**
+   * Create a new ${name}
+   */
+  async create(data: ${name}Create) {
+    const response = await apiClient.post<${name}>(BASE_URL, '${createEndpoint.path}', data)
+    return response.data
+  },
+
+  /**
+   * Update an existing ${name}
+   */
+  async update(id: string, data: ${name}Update) {
+    const response = await apiClient.put<${name}>(BASE_URL, \`${pathWithId(updateEndpoint.path)}\`, data)
+    return response.data
+  },
+
+  /**
+   * Delete a ${name}
+   */
+  async delete(id: string) {
+    const response = await apiClient.delete<void>(BASE_URL, \`${pathWithId(deleteEndpoint.path)}\`)
+    return response.data
+  },
+}
+
+// Type for the entity (inferred from schema)
+export interface ${name} extends ${name}Create {
+  id: string
+}
+`,
+    };
+}
+/**
+ * Generate barrel export file for all services
+ *
+ * @param entities - Entities with external source to include
+ * @returns Generated file for services/index.ts
+ */
+function generateServiceIndex(entities) {
+    const externalEntities = entities.filter(e => e.source?.type === 'external');
+    const exports = externalEntities
+        .map(e => `export { ${e.name.toLowerCase()}Service } from './${e.name.toLowerCase()}Service'`)
+        .join('\n');
+    return {
+        path: 'services/index.ts',
+        content: `// Auto-generated service exports
+// Do not edit manually - regenerate with: npx archetype generate
+
+export { apiClient } from './apiClient'
+${exports}
+`,
+    };
+}
+exports.serviceGenerator = {
+    name: 'service-layer',
+    description: 'Generate service layer for external APIs',
+    generate(manifest, ctx) {
+        const files = [];
+        // Collect entities with external source (from entity or manifest level)
+        const entitiesWithSource = [];
+        for (const entity of manifest.entities) {
+            // Entity-level source takes precedence
+            const source = entity.source || manifest.source;
+            if (source?.type === 'external') {
+                entitiesWithSource.push({ entity, source });
+            }
+        }
+        // Only generate if we have external entities
+        if (entitiesWithSource.length === 0) {
+            return files;
+        }
+        // Generate base API client
+        files.push(generateApiClient());
+        // Generate service for each external entity
+        for (const { entity, source } of entitiesWithSource) {
+            files.push(generateEntityService(entity, source, ctx));
+        }
+        // Generate service index
+        files.push(generateServiceIndex(entitiesWithSource.map(e => e.entity)));
+        return files;
+    },
+};

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

@@ -0,0 +1,21 @@
+/**
+ * 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
+ */
+import type { Generator } from '../../../template/types';
+export declare const validationGenerator: Generator;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../src/templates/nextjs-drizzle-trpc/generators/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,yBAAyB,CAAA;AAqOvE,eAAO,MAAM,mBAAmB,EAAE,SAYjC,CAAA"}