archetype-engine 2.0.0

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

@@ -0,0 +1,20 @@
+/**
+ * Auth.js (next-auth v5) Schema Generator
+ *
+ * Generates database schema for Auth.js/NextAuth.js authentication tables.
+ * Only runs when auth.enabled is true in the manifest.
+ *
+ * Generated files:
+ * - db/auth-schema.ts - Auth tables (users, accounts, sessions, verificationTokens)
+ *
+ * Features:
+ * - Supports SQLite, PostgreSQL, and MySQL databases
+ * - Uses official Auth.js/Drizzle adapter schema format
+ * - Includes proper foreign key references with cascade delete
+ * - Uses composite primary keys for accounts and verification tokens
+ *
+ * @module generators/auth
+ */
+import type { Generator } from '../../../template/types';
+export declare const authGenerator: Generator;
+//# sourceMappingURL=auth.d.ts.map

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

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

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

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * Auth.js (next-auth v5) Schema Generator
+ *
+ * Generates database schema for Auth.js/NextAuth.js authentication tables.
+ * Only runs when auth.enabled is true in the manifest.
+ *
+ * Generated files:
+ * - db/auth-schema.ts - Auth tables (users, accounts, sessions, verificationTokens)
+ *
+ * Features:
+ * - Supports SQLite, PostgreSQL, and MySQL databases
+ * - Uses official Auth.js/Drizzle adapter schema format
+ * - Includes proper foreign key references with cascade delete
+ * - Uses composite primary keys for accounts and verification tokens
+ *
+ * @module generators/auth
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authGenerator = void 0;
+/**
+ * Generate SQLite-specific auth schema
+ *
+ * Uses sqliteTable with integer timestamps (timestamp_ms mode).
+ *
+ * @returns SQLite auth schema as string
+ */
+function generateSqliteAuthSchema() {
+    return `// Auto-generated Auth.js schema for SQLite
+// Do not edit manually - regenerate with: npx archetype generate
+
+import {
+  integer,
+  sqliteTable,
+  text,
+  primaryKey,
+} from 'drizzle-orm/sqlite-core'
+import type { AdapterAccountType } from 'next-auth/adapters'
+
+export const users = sqliteTable('user', {
+  id: text('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  name: text('name'),
+  email: text('email').unique(),
+  emailVerified: integer('emailVerified', { mode: 'timestamp_ms' }),
+  image: text('image'),
+})
+
+export const accounts = sqliteTable(
+  'account',
+  {
+    userId: text('userId')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    type: text('type').$type<AdapterAccountType>().notNull(),
+    provider: text('provider').notNull(),
+    providerAccountId: text('providerAccountId').notNull(),
+    refresh_token: text('refresh_token'),
+    access_token: text('access_token'),
+    expires_at: integer('expires_at'),
+    token_type: text('token_type'),
+    scope: text('scope'),
+    id_token: text('id_token'),
+    session_state: text('session_state'),
+  },
+  (account) => ({
+    compoundKey: primaryKey({ columns: [account.provider, account.providerAccountId] }),
+  })
+)
+
+export const sessions = sqliteTable('session', {
+  sessionToken: text('sessionToken').primaryKey(),
+  userId: text('userId')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
+})
+
+export const verificationTokens = sqliteTable(
+  'verificationToken',
+  {
+    identifier: text('identifier').notNull(),
+    token: text('token').notNull(),
+    expires: integer('expires', { mode: 'timestamp_ms' }).notNull(),
+  },
+  (verificationToken) => ({
+    compositePk: primaryKey({
+      columns: [verificationToken.identifier, verificationToken.token],
+    }),
+  })
+)
+`;
+}
+/**
+ * Generate PostgreSQL-specific auth schema
+ *
+ * Uses pgTable with native timestamp columns (date mode).
+ *
+ * @returns PostgreSQL auth schema as string
+ */
+function generatePostgresAuthSchema() {
+    return `// Auto-generated Auth.js schema for PostgreSQL
+// Do not edit manually - regenerate with: npx archetype generate
+
+import {
+  integer,
+  pgTable,
+  primaryKey,
+  text,
+  timestamp,
+} from 'drizzle-orm/pg-core'
+import type { AdapterAccountType } from 'next-auth/adapters'
+
+export const users = pgTable('user', {
+  id: text('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  name: text('name'),
+  email: text('email').unique(),
+  emailVerified: timestamp('emailVerified', { mode: 'date' }),
+  image: text('image'),
+})
+
+export const accounts = pgTable(
+  'account',
+  {
+    userId: text('userId')
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    type: text('type').$type<AdapterAccountType>().notNull(),
+    provider: text('provider').notNull(),
+    providerAccountId: text('providerAccountId').notNull(),
+    refresh_token: text('refresh_token'),
+    access_token: text('access_token'),
+    expires_at: integer('expires_at'),
+    token_type: text('token_type'),
+    scope: text('scope'),
+    id_token: text('id_token'),
+    session_state: text('session_state'),
+  },
+  (account) => ({
+    compoundKey: primaryKey({ columns: [account.provider, account.providerAccountId] }),
+  })
+)
+
+export const sessions = pgTable('session', {
+  sessionToken: text('sessionToken').primaryKey(),
+  userId: text('userId')
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  expires: timestamp('expires', { mode: 'date' }).notNull(),
+})
+
+export const verificationTokens = pgTable(
+  'verificationToken',
+  {
+    identifier: text('identifier').notNull(),
+    token: text('token').notNull(),
+    expires: timestamp('expires', { mode: 'date' }).notNull(),
+  },
+  (verificationToken) => ({
+    compositePk: primaryKey({
+      columns: [verificationToken.identifier, verificationToken.token],
+    }),
+  })
+)
+`;
+}
+/**
+ * Generate MySQL-specific auth schema
+ *
+ * Uses mysqlTable with varchar fields (255 length) and timestamp columns.
+ *
+ * @returns MySQL auth schema as string
+ */
+function generateMysqlAuthSchema() {
+    return `// Auto-generated Auth.js schema for MySQL
+// Do not edit manually - regenerate with: npx archetype generate
+
+import {
+  int,
+  mysqlTable,
+  primaryKey,
+  varchar,
+  timestamp,
+} from 'drizzle-orm/mysql-core'
+import type { AdapterAccountType } from 'next-auth/adapters'
+
+export const users = mysqlTable('user', {
+  id: varchar('id', { length: 255 })
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  name: varchar('name', { length: 255 }),
+  email: varchar('email', { length: 255 }).unique(),
+  emailVerified: timestamp('emailVerified', { fsp: 3, mode: 'date' }),
+  image: varchar('image', { length: 255 }),
+})
+
+export const accounts = mysqlTable(
+  'account',
+  {
+    userId: varchar('userId', { length: 255 })
+      .notNull()
+      .references(() => users.id, { onDelete: 'cascade' }),
+    type: varchar('type', { length: 255 }).$type<AdapterAccountType>().notNull(),
+    provider: varchar('provider', { length: 255 }).notNull(),
+    providerAccountId: varchar('providerAccountId', { length: 255 }).notNull(),
+    refresh_token: varchar('refresh_token', { length: 255 }),
+    access_token: varchar('access_token', { length: 255 }),
+    expires_at: int('expires_at'),
+    token_type: varchar('token_type', { length: 255 }),
+    scope: varchar('scope', { length: 255 }),
+    id_token: varchar('id_token', { length: 2048 }),
+    session_state: varchar('session_state', { length: 255 }),
+  },
+  (account) => ({
+    compoundKey: primaryKey({ columns: [account.provider, account.providerAccountId] }),
+  })
+)
+
+export const sessions = mysqlTable('session', {
+  sessionToken: varchar('sessionToken', { length: 255 }).primaryKey(),
+  userId: varchar('userId', { length: 255 })
+    .notNull()
+    .references(() => users.id, { onDelete: 'cascade' }),
+  expires: timestamp('expires', { mode: 'date' }).notNull(),
+})
+
+export const verificationTokens = mysqlTable(
+  'verificationToken',
+  {
+    identifier: varchar('identifier', { length: 255 }).notNull(),
+    token: varchar('token', { length: 255 }).notNull(),
+    expires: timestamp('expires', { mode: 'date' }).notNull(),
+  },
+  (verificationToken) => ({
+    compositePk: primaryKey({
+      columns: [verificationToken.identifier, verificationToken.token],
+    }),
+  })
+)
+`;
+}
+exports.authGenerator = {
+    name: 'auth-schema',
+    description: 'Generate Auth.js schema for next-auth',
+    generate(manifest, ctx) {
+        // Skip if auth is not enabled
+        if (!manifest.auth.enabled) {
+            return [];
+        }
+        // Generate auth schema based on database type
+        let schemaContent;
+        if (ctx.database.isSqlite) {
+            schemaContent = generateSqliteAuthSchema();
+        }
+        else if (ctx.database.isPostgres) {
+            schemaContent = generatePostgresAuthSchema();
+        }
+        else if (ctx.database.isMysql) {
+            schemaContent = generateMysqlAuthSchema();
+        }
+        else {
+            // Default to SQLite for unknown
+            schemaContent = generateSqliteAuthSchema();
+        }
+        return [{
+                path: 'db/auth-schema.ts',
+                content: schemaContent,
+            }];
+    },
+};

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

@@ -0,0 +1,22 @@
+/**
+ * CRUD Hooks Generator
+ *
+ * Generates type-safe hook files for CRUD operations.
+ * Users implement hooks in these files to add custom business logic.
+ *
+ * Generated files:
+ * - hooks/types.ts - Type definitions for all hook signatures
+ * - hooks/{entity}.ts - Hook implementations (user-editable)
+ *
+ * Features:
+ * - Type-safe hook signatures with proper input/output types
+ * - beforeCreate/afterCreate hooks for create operations
+ * - beforeUpdate/afterUpdate hooks for update operations
+ * - beforeRemove/afterRemove hooks for delete operations
+ * - Hooks can modify input (before*) or perform side effects (after*)
+ *
+ * @module generators/crud-hooks
+ */
+import type { Generator } from '../../../template/types';
+export declare const crudHooksGenerator: Generator;
+//# sourceMappingURL=crud-hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crud-hooks.d.ts","sourceRoot":"","sources":["../../../../../src/templates/nextjs-drizzle-trpc/generators/crud-hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAiB,MAAM,yBAAyB,CAAA;AAiNvE,eAAO,MAAM,kBAAkB,EAAE,SA8BhC,CAAA"}

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

@@ -0,0 +1,237 @@
+"use strict";
+/**
+ * CRUD Hooks Generator
+ *
+ * Generates type-safe hook files for CRUD operations.
+ * Users implement hooks in these files to add custom business logic.
+ *
+ * Generated files:
+ * - hooks/types.ts - Type definitions for all hook signatures
+ * - hooks/{entity}.ts - Hook implementations (user-editable)
+ *
+ * Features:
+ * - Type-safe hook signatures with proper input/output types
+ * - beforeCreate/afterCreate hooks for create operations
+ * - beforeUpdate/afterUpdate hooks for update operations
+ * - beforeRemove/afterRemove hooks for delete operations
+ * - Hooks can modify input (before*) or perform side effects (after*)
+ *
+ * @module generators/crud-hooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crudHooksGenerator = void 0;
+/**
+ * Check if entity has any hooks enabled
+ */
+function hasAnyHooks(hooks) {
+    return Object.values(hooks).some(v => v);
+}
+/**
+ * Check if manifest has any entities with hooks
+ */
+function manifestHasHooks(manifest) {
+    return manifest.entities.some(e => hasAnyHooks(e.hooks));
+}
+/**
+ * Generate the shared hooks types file
+ */
+function generateHooksTypes(manifest) {
+    const entityTypes = [];
+    for (const entity of manifest.entities) {
+        if (!hasAnyHooks(entity.hooks))
+            continue;
+        const name = entity.name;
+        const hooks = entity.hooks;
+        // Build field types for CreateInput
+        const createFields = Object.entries(entity.fields)
+            .filter(([_, f]) => f.type !== 'computed')
+            .map(([fieldName, config]) => {
+            const optional = !config.required ? '?' : '';
+            let type = 'string';
+            if (config.type === 'number')
+                type = 'number';
+            if (config.type === 'boolean')
+                type = 'boolean';
+            if (config.type === 'enum' && config.enumValues) {
+                type = config.enumValues.map(v => `'${v}'`).join(' | ');
+            }
+            return `  ${fieldName}${optional}: ${type}`;
+        })
+            .join('\n');
+        // Build field types for UpdateInput (all optional)
+        const updateFields = Object.entries(entity.fields)
+            .filter(([_, f]) => f.type !== 'computed')
+            .map(([fieldName, config]) => {
+            let type = 'string';
+            if (config.type === 'number')
+                type = 'number';
+            if (config.type === 'boolean')
+                type = 'boolean';
+            if (config.type === 'enum' && config.enumValues) {
+                type = config.enumValues.map(v => `'${v}'`).join(' | ');
+            }
+            return `  ${fieldName}?: ${type}`;
+        })
+            .join('\n');
+        // Build hook interface members
+        const hookMembers = [];
+        if (hooks.beforeCreate) {
+            hookMembers.push(`  /** Called before creating. Return modified input or throw to abort. */
+  beforeCreate?: (input: ${name}CreateInput, ctx: HookContext) => Promise<${name}CreateInput> | ${name}CreateInput`);
+        }
+        if (hooks.afterCreate) {
+            hookMembers.push(`  /** Called after creation. For side effects like sending emails. */
+  afterCreate?: (record: ${name}Record, ctx: HookContext) => Promise<void> | void`);
+        }
+        if (hooks.beforeUpdate) {
+            hookMembers.push(`  /** Called before updating. Return modified input or throw to abort. */
+  beforeUpdate?: (id: string, input: ${name}UpdateInput, ctx: HookContext) => Promise<${name}UpdateInput> | ${name}UpdateInput`);
+        }
+        if (hooks.afterUpdate) {
+            hookMembers.push(`  /** Called after update. For side effects. */
+  afterUpdate?: (record: ${name}Record, ctx: HookContext) => Promise<void> | void`);
+        }
+        if (hooks.beforeRemove) {
+            hookMembers.push(`  /** Called before removal. Throw to abort deletion. */
+  beforeRemove?: (id: string, ctx: HookContext) => Promise<void> | void`);
+        }
+        if (hooks.afterRemove) {
+            hookMembers.push(`  /** Called after removal. For cleanup/archival. */
+  afterRemove?: (record: ${name}Record, ctx: HookContext) => Promise<void> | void`);
+        }
+        entityTypes.push(`
+// ============ ${name} Hooks ============
+
+export interface ${name}CreateInput {
+${createFields}
+}
+
+export interface ${name}UpdateInput {
+${updateFields}
+}
+
+export interface ${name}Record extends ${name}CreateInput {
+  id: string
+  createdAt: string
+  updatedAt: string
+}
+
+export interface ${name}Hooks {
+${hookMembers.join('\n')}
+}`);
+    }
+    return `// Auto-generated hook types
+// Do not edit manually - regenerate with: npx archetype generate
+
+/**
+ * Hook context passed to all hooks
+ * Contains user session and other request context
+ */
+export interface HookContext {
+  /** User session (if authenticated) */
+  user?: {
+    id: string
+    email?: string
+    name?: string
+  }
+  /** Request headers */
+  headers?: Record<string, string>
+}
+${entityTypes.join('\n')}
+`;
+}
+/**
+ * Generate a stub hooks file for an entity
+ */
+function generateEntityHooks(entity) {
+    const name = entity.name;
+    const lowerName = name.toLowerCase();
+    const hooks = entity.hooks;
+    const imports = [`${name}Hooks`, 'HookContext'];
+    if (hooks.beforeCreate || hooks.afterCreate) {
+        imports.push(`${name}CreateInput`);
+    }
+    if (hooks.beforeUpdate) {
+        imports.push(`${name}UpdateInput`);
+    }
+    if (hooks.afterCreate || hooks.afterUpdate || hooks.afterRemove) {
+        imports.push(`${name}Record`);
+    }
+    const hookImplementations = [];
+    if (hooks.beforeCreate) {
+        hookImplementations.push(`
+  async beforeCreate(input, ctx) {
+    // Validate business rules or modify input
+    // throw new Error('message') to abort
+    return input
+  },`);
+    }
+    if (hooks.afterCreate) {
+        hookImplementations.push(`
+  async afterCreate(record, ctx) {
+    // Side effects: send email, audit log, sync external system
+  },`);
+    }
+    if (hooks.beforeUpdate) {
+        hookImplementations.push(`
+  async beforeUpdate(id, input, ctx) {
+    // Validate business rules or modify input
+    // throw new Error('message') to abort
+    return input
+  },`);
+    }
+    if (hooks.afterUpdate) {
+        hookImplementations.push(`
+  async afterUpdate(record, ctx) {
+    // Side effects: sync external system, invalidate cache
+  },`);
+    }
+    if (hooks.beforeRemove) {
+        hookImplementations.push(`
+  async beforeRemove(id, ctx) {
+    // Check if deletion is allowed
+    // throw new Error('message') to abort
+  },`);
+    }
+    if (hooks.afterRemove) {
+        hookImplementations.push(`
+  async afterRemove(record, ctx) {
+    // Cleanup: archive data, remove related records
+  },`);
+    }
+    return `// ${name} CRUD Hooks
+// Implement your business logic here
+// This file is user-managed - it won't be overwritten by regenerate
+
+import type { ${imports.join(', ')} } from './types'
+
+export const ${lowerName}Hooks: ${name}Hooks = {${hookImplementations.join('')}
+}
+`;
+}
+exports.crudHooksGenerator = {
+    name: 'crud-hooks',
+    description: 'Generate CRUD hook files',
+    generate(manifest, ctx) {
+        // Only generate if at least one entity has hooks
+        if (!manifestHasHooks(manifest)) {
+            return [];
+        }
+        const files = [];
+        // Generate shared types file
+        files.push({
+            path: 'hooks/types.ts',
+            content: generateHooksTypes(manifest),
+        });
+        // Generate hook implementation files for entities with hooks
+        for (const entity of manifest.entities) {
+            if (hasAnyHooks(entity.hooks)) {
+                files.push({
+                    path: `hooks/${entity.name.toLowerCase()}.ts`,
+                    content: generateEntityHooks(entity),
+                });
+            }
+        }
+        return files;
+    },
+};

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

@@ -0,0 +1,30 @@
+/**
+ * React Hooks Generator
+ *
+ * Generates React hooks for data fetching and form handling using tRPC and React Hook Form.
+ * Provides a complete set of hooks for each entity's CRUD operations.
+ *
+ * Generated files:
+ * - hooks/use{Entity}.ts - Hooks for list, get, create, edit, and remove operations
+ *
+ * Generated hooks per entity:
+ * - use{Entity}s() - List all entities (useQuery)
+ * - use{Entity}(id) - Get single entity by ID (useQuery)
+ * - use{Entity}Form() - Create form with validation and mutation
+ * - use{Entity}EditForm(id) - Edit form with data loading and mutation
+ * - use{Entity}Remove() - Delete mutation with cache invalidation
+ * - useCreate{Entity}() - Create mutation without form
+ * - useUpdate{Entity}() - Update mutation without form
+ *
+ * Features:
+ * - Zod validation integration via zodResolver
+ * - Automatic tRPC cache invalidation on mutations
+ * - i18n support for validation messages when multiple languages configured
+ * - Form reset on successful create
+ * - Null-to-undefined conversion for form compatibility
+ *
+ * @module generators/hooks
+ */
+import type { Generator } from '../../../template/types';
+export declare const hooksGenerator: Generator;
+//# sourceMappingURL=hooks.d.ts.map

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

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