archetype-engine 2.0.0

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

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hooksGenerator = void 0;
+/**
+ * Generate filter type definitions for an entity
+ */
+function generateFilterTypes(entity) {
+    const filterFields = Object.entries(entity.fields).map(([fieldName, field]) => {
+        switch (field.type) {
+            case 'text':
+                return `  ${fieldName}?: string | {
+    eq?: string
+    ne?: string
+    contains?: string
+    startsWith?: string
+    endsWith?: string
+  }`;
+            case 'number':
+                return `  ${fieldName}?: number | {
+    eq?: number
+    ne?: number
+    gt?: number
+    gte?: number
+    lt?: number
+    lte?: number
+  }`;
+            case 'boolean':
+                return `  ${fieldName}?: boolean`;
+            case 'date':
+                return `  ${fieldName}?: string | {
+    eq?: string
+    ne?: string
+    gt?: string
+    gte?: string
+    lt?: string
+    lte?: string
+  }`;
+            default:
+                return `  ${fieldName}?: string`;
+        }
+    }).join('\n');
+    // Get field names for orderBy
+    const fieldNames = Object.keys(entity.fields);
+    const orderByFields = [...fieldNames, 'createdAt', 'updatedAt'];
+    return `// Filter operators for ${entity.name}
+export interface ${entity.name}Filter {
+${filterFields}
+}
+
+// OrderBy options for ${entity.name}
+export interface ${entity.name}OrderBy {
+  field: ${orderByFields.map(f => `'${f}'`).join(' | ')}
+  direction?: 'asc' | 'desc'
+}`;
+}
+/**
+ * JavaScript reserved words that can't be used as variable names
+ */
+const JS_RESERVED_WORDS = new Set([
+    'break', 'case', 'catch', 'continue', 'debugger', 'default', 'delete',
+    'do', 'else', 'finally', 'for', 'function', 'if', 'in', 'instanceof',
+    'new', 'return', 'switch', 'this', 'throw', 'try', 'typeof', 'var',
+    'void', 'while', 'with', 'class', 'const', 'enum', 'export', 'extends',
+    'import', 'super', 'implements', 'interface', 'let', 'package', 'private',
+    'protected', 'public', 'static', 'yield', 'await', 'null', 'undefined', 'true', 'false'
+]);
+/**
+ * Get a safe variable name, prefixing with underscore if it's a reserved word
+ */
+function getSafeVarName(name) {
+    return JS_RESERVED_WORDS.has(name.toLowerCase()) ? `_${name.toLowerCase()}` : name.toLowerCase();
+}
+/**
+ * Generate complete hooks file for an entity
+ *
+ * @param entity - Entity IR with name and field definitions
+ * @param manifest - Manifest IR with i18n configuration
+ * @returns Complete hooks file content as string
+ */
+function generateEntityHooks(entity, manifest) {
+    const name = entity.name;
+    const lowerName = name.toLowerCase();
+    const safeVarName = getSafeVarName(name);
+    const useI18n = manifest.i18n.languages.length > 1;
+    // Schema imports
+    const schemaImport = useI18n
+        ? `import { ${lowerName}CreateSchemaI18n, ${lowerName}UpdateSchemaI18n, ${name}Create, ${name}Update } from '@/generated/schemas/${lowerName}'`
+        : `import { ${lowerName}CreateSchema, ${lowerName}UpdateSchema, ${name}Create, ${name}Update } from '@/generated/schemas/${lowerName}'`;
+    const i18nImport = useI18n
+        ? `import { useTranslations } from 'next-intl'`
+        : '';
+    const tDeclaration = useI18n
+        ? `  const t = useTranslations('validation')`
+        : '';
+    const resolverSchema = useI18n
+        ? `${lowerName}CreateSchemaI18n(t)`
+        : `${lowerName}CreateSchema`;
+    const updateResolverSchema = useI18n
+        ? `${lowerName}UpdateSchemaI18n(t)`
+        : `${lowerName}UpdateSchema`;
+    // Generate filter types
+    const filterTypes = generateFilterTypes(entity);
+    return `// Auto-generated hooks for ${name}
+// Do not edit manually - regenerate with: npx archetype generate
+
+'use client'
+
+import { useMemo } from 'react'
+import { useForm } from 'react-hook-form'
+import { zodResolver } from '@hookform/resolvers/zod'
+import { trpc } from '@/lib/trpc'
+${i18nImport}
+${schemaImport}
+
+// Convert null values to undefined for form compatibility
+type NullToUndefined<T> = {
+  [K in keyof T]: T[K] extends null ? undefined : Exclude<T[K], null>
+}
+
+function nullToUndefined<T extends Record<string, unknown>>(
+  obj: T | null | undefined
+): NullToUndefined<T> | undefined {
+  if (!obj) return undefined
+  return Object.fromEntries(
+    Object.entries(obj).map(([k, v]) => [k, v === null ? undefined : v])
+  ) as NullToUndefined<T>
+}
+
+${filterTypes}
+
+// ============ LIST WITH PAGINATION, FILTERING, SORTING, AND SEARCH ============
+export interface Use${name}sOptions {
+  // Pagination
+  page?: number
+  limit?: number
+  // Filtering
+  where?: ${name}Filter
+  // Sorting
+  orderBy?: ${name}OrderBy
+  // Search across text fields
+  search?: string
+}
+
+// React Query options for controlling query behavior
+export interface QueryOptions {
+  enabled?: boolean
+}
+
+export function use${name}s(options?: Use${name}sOptions, queryOptions?: QueryOptions) {
+  return trpc.${lowerName}.list.useQuery({
+    page: options?.page ?? 1,
+    limit: options?.limit ?? 20,
+    where: options?.where,
+    orderBy: options?.orderBy,
+    search: options?.search,
+  }, queryOptions)
+}
+
+// ============ GET ============
+export function use${name}(id: string) {
+  return trpc.${lowerName}.get.useQuery({ id }, {
+    enabled: !!id,
+  })
+}
+
+// ============ CREATE FORM ============
+export function use${name}Form() {
+${tDeclaration}
+  const utils = trpc.useUtils()
+
+  const form = useForm<${name}Create>({
+    resolver: zodResolver(${resolverSchema}),
+  })
+
+  const mutation = trpc.${lowerName}.create.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.list.invalidate()
+      form.reset()
+    },
+  })
+
+  return {
+    ...form,
+    submit: form.handleSubmit((data) => mutation.mutate(data)),
+    isPending: mutation.isPending,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+    reset: () => {
+      form.reset()
+      mutation.reset()
+    },
+  }
+}
+
+// ============ EDIT FORM ============
+export function use${name}EditForm(id: string) {
+${tDeclaration}
+  const utils = trpc.useUtils()
+  const { data: ${safeVarName}, isLoading } = trpc.${lowerName}.get.useQuery({ id })
+
+  const mutation = trpc.${lowerName}.update.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.invalidate()
+    },
+  })
+
+  const formValues = useMemo(() => nullToUndefined(${safeVarName}) as ${name}Update | undefined, [${safeVarName}])
+
+  const form = useForm<${name}Update>({
+    resolver: zodResolver(${updateResolverSchema}),
+    values: formValues,
+  })
+
+  return {
+    ...form,
+    submit: form.handleSubmit((data) => mutation.mutate({ id, data })),
+    isPending: mutation.isPending,
+    isLoading,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+  }
+}
+
+// ============ REMOVE ============
+export function use${name}Remove() {
+  const utils = trpc.useUtils()
+  const mutation = trpc.${lowerName}.remove.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.list.invalidate()
+    },
+  })
+
+  return {
+    remove: (id: string) => mutation.mutate({ id }),
+    isPending: mutation.isPending,
+    error: mutation.error,
+    isSuccess: mutation.isSuccess,
+  }
+}
+
+// ============ CREATE MUTATION (without form) ============
+export function useCreate${name}() {
+  const utils = trpc.useUtils()
+  return trpc.${lowerName}.create.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.list.invalidate()
+    },
+  })
+}
+
+// ============ UPDATE MUTATION (without form) ============
+export function useUpdate${name}() {
+  const utils = trpc.useUtils()
+  return trpc.${lowerName}.update.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.invalidate()
+    },
+  })
+}
+
+// ============ BATCH OPERATIONS ============
+
+// Create multiple ${name}s at once
+export function useCreateMany${name}s() {
+  const utils = trpc.useUtils()
+  const mutation = trpc.${lowerName}.createMany.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.list.invalidate()
+    },
+  })
+
+  return {
+    createMany: (items: ${name}Create[]) => mutation.mutate({ items }),
+    ...mutation,
+  }
+}
+
+// Update multiple ${name}s at once
+export function useUpdateMany${name}s() {
+  const utils = trpc.useUtils()
+  const mutation = trpc.${lowerName}.updateMany.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.invalidate()
+    },
+  })
+
+  return {
+    updateMany: (items: { id: string; data: ${name}Update }[]) => mutation.mutate({ items }),
+    ...mutation,
+  }
+}
+
+// Remove multiple ${name}s at once
+export function useRemoveMany${name}s() {
+  const utils = trpc.useUtils()
+  const mutation = trpc.${lowerName}.removeMany.useMutation({
+    onSuccess: () => {
+      utils.${lowerName}.list.invalidate()
+    },
+  })
+
+  return {
+    removeMany: (ids: string[]) => mutation.mutate({ ids }),
+    ...mutation,
+  }
+}
+`;
+}
+exports.hooksGenerator = {
+    name: 'react-hooks',
+    description: 'Generate React hooks with React Hook Form integration',
+    generate(manifest, ctx) {
+        return manifest.entities.map(entity => ({
+            path: `hooks/use${entity.name}.ts`,
+            content: generateEntityHooks(entity, manifest),
+        }));
+    },
+};

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

@@ -0,0 +1,25 @@
+/**
+ * i18n Translation Files Generator
+ *
+ * Generates JSON translation files for internationalized validation messages.
+ * Only runs when multiple languages are configured in the manifest.
+ *
+ * Generated files:
+ * - i18n/{lang}/validation.json - Validation error messages
+ * - i18n/{lang}/fields.json - Field labels per entity
+ * - i18n/{lang}/entities.json - Entity display names
+ *
+ * Supported languages (with built-in translations):
+ * - en (English), es (Spanish), fr (French), de (German)
+ * - pt (Portuguese), it (Italian), ja (Japanese), zh (Chinese), ko (Korean)
+ *
+ * Features:
+ * - Parameterized message templates ({field}, {min}, {max}, {values})
+ * - Compatible with next-intl ICU message format
+ * - Falls back to English for unsupported languages
+ *
+ * @module generators/i18n
+ */
+import type { Generator } from '../../../template/types';
+export declare const i18nGenerator: Generator;
+//# sourceMappingURL=i18n.d.ts.map

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

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

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

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * i18n Translation Files Generator
+ *
+ * Generates JSON translation files for internationalized validation messages.
+ * Only runs when multiple languages are configured in the manifest.
+ *
+ * Generated files:
+ * - i18n/{lang}/validation.json - Validation error messages
+ * - i18n/{lang}/fields.json - Field labels per entity
+ * - i18n/{lang}/entities.json - Entity display names
+ *
+ * Supported languages (with built-in translations):
+ * - en (English), es (Spanish), fr (French), de (German)
+ * - pt (Portuguese), it (Italian), ja (Japanese), zh (Chinese), ko (Korean)
+ *
+ * Features:
+ * - Parameterized message templates ({field}, {min}, {max}, {values})
+ * - Compatible with next-intl ICU message format
+ * - Falls back to English for unsupported languages
+ *
+ * @module generators/i18n
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nGenerator = void 0;
+// Default validation messages per language
+const defaultValidationMessages = {
+    en: {
+        required: '{field} is required',
+        email: 'Invalid email address',
+        url: 'Invalid URL',
+        min: '{field} must be at least {min}',
+        max: '{field} must be at most {max}',
+        minLength: '{field} must be at least {min} characters',
+        maxLength: '{field} must be at most {max} characters',
+        oneOf: '{field} must be one of: {values}',
+        pattern: '{field} format is invalid',
+        integer: '{field} must be a whole number',
+        positive: '{field} must be positive',
+    },
+    es: {
+        required: '{field} es requerido',
+        email: 'Correo electrónico inválido',
+        url: 'URL inválida',
+        min: '{field} debe ser al menos {min}',
+        max: '{field} debe ser como máximo {max}',
+        minLength: '{field} debe tener al menos {min} caracteres',
+        maxLength: '{field} debe tener como máximo {max} caracteres',
+        oneOf: '{field} debe ser uno de: {values}',
+        pattern: 'Formato de {field} inválido',
+        integer: '{field} debe ser un número entero',
+        positive: '{field} debe ser positivo',
+    },
+    fr: {
+        required: '{field} est requis',
+        email: 'Adresse e-mail invalide',
+        url: 'URL invalide',
+        min: '{field} doit être au moins {min}',
+        max: '{field} doit être au plus {max}',
+        minLength: '{field} doit contenir au moins {min} caractères',
+        maxLength: '{field} doit contenir au plus {max} caractères',
+        oneOf: '{field} doit être l\'un des: {values}',
+        pattern: 'Format de {field} invalide',
+        integer: '{field} doit être un nombre entier',
+        positive: '{field} doit être positif',
+    },
+    de: {
+        required: '{field} ist erforderlich',
+        email: 'Ungültige E-Mail-Adresse',
+        url: 'Ungültige URL',
+        min: '{field} muss mindestens {min} sein',
+        max: '{field} darf höchstens {max} sein',
+        minLength: '{field} muss mindestens {min} Zeichen haben',
+        maxLength: '{field} darf höchstens {max} Zeichen haben',
+        oneOf: '{field} muss eines von: {values} sein',
+        pattern: 'Format von {field} ist ungültig',
+        integer: '{field} muss eine ganze Zahl sein',
+        positive: '{field} muss positiv sein',
+    },
+    pt: {
+        required: '{field} é obrigatório',
+        email: 'Endereço de e-mail inválido',
+        url: 'URL inválida',
+        min: '{field} deve ser pelo menos {min}',
+        max: '{field} deve ser no máximo {max}',
+        minLength: '{field} deve ter pelo menos {min} caracteres',
+        maxLength: '{field} deve ter no máximo {max} caracteres',
+        oneOf: '{field} deve ser um de: {values}',
+        pattern: 'Formato de {field} inválido',
+        integer: '{field} deve ser um número inteiro',
+        positive: '{field} deve ser positivo',
+    },
+    it: {
+        required: '{field} è richiesto',
+        email: 'Indirizzo email non valido',
+        url: 'URL non valido',
+        min: '{field} deve essere almeno {min}',
+        max: '{field} deve essere al massimo {max}',
+        minLength: '{field} deve contenere almeno {min} caratteri',
+        maxLength: '{field} deve contenere al massimo {max} caratteri',
+        oneOf: '{field} deve essere uno tra: {values}',
+        pattern: 'Formato di {field} non valido',
+        integer: '{field} deve essere un numero intero',
+        positive: '{field} deve essere positivo',
+    },
+    ja: {
+        required: '{field}は必須です',
+        email: '無効なメールアドレス',
+        url: '無効なURL',
+        min: '{field}は{min}以上である必要があります',
+        max: '{field}は{max}以下である必要があります',
+        minLength: '{field}は{min}文字以上である必要があります',
+        maxLength: '{field}は{max}文字以下である必要があります',
+        oneOf: '{field}は次のいずれかである必要があります: {values}',
+        pattern: '{field}の形式が無効です',
+        integer: '{field}は整数である必要があります',
+        positive: '{field}は正の数である必要があります',
+    },
+    zh: {
+        required: '{field}是必填项',
+        email: '无效的电子邮件地址',
+        url: '无效的URL',
+        min: '{field}必须至少为{min}',
+        max: '{field}必须最多为{max}',
+        minLength: '{field}必须至少为{min}个字符',
+        maxLength: '{field}必须最多为{max}个字符',
+        oneOf: '{field}必须是以下之一: {values}',
+        pattern: '{field}格式无效',
+        integer: '{field}必须是整数',
+        positive: '{field}必须是正数',
+    },
+    ko: {
+        required: '{field}은(는) 필수입니다',
+        email: '유효하지 않은 이메일 주소',
+        url: '유효하지 않은 URL',
+        min: '{field}은(는) 최소 {min}이어야 합니다',
+        max: '{field}은(는) 최대 {max}이어야 합니다',
+        minLength: '{field}은(는) 최소 {min}자 이상이어야 합니다',
+        maxLength: '{field}은(는) 최대 {max}자 이하이어야 합니다',
+        oneOf: '{field}은(는) 다음 중 하나여야 합니다: {values}',
+        pattern: '{field} 형식이 유효하지 않습니다',
+        integer: '{field}은(는) 정수여야 합니다',
+        positive: '{field}은(는) 양수여야 합니다',
+    },
+};
+/**
+ * Generate field labels mapping from entities
+ *
+ * Extracts labels from field configurations, falling back to field names.
+ *
+ * @param entities - Array of entity IRs with field definitions
+ * @returns Nested object of entity -> field -> label
+ */
+function generateFieldLabels(entities) {
+    const labels = {};
+    for (const entity of entities) {
+        const entityLabels = {};
+        for (const [fieldName, config] of Object.entries(entity.fields)) {
+            entityLabels[fieldName] = config.label || fieldName;
+        }
+        labels[entity.name.toLowerCase()] = entityLabels;
+    }
+    return labels;
+}
+exports.i18nGenerator = {
+    name: 'i18n-files',
+    description: 'Generate i18n translation files',
+    generate(manifest, ctx) {
+        const files = [];
+        // Only generate if multiple languages are configured
+        if (manifest.i18n.languages.length <= 1) {
+            return files;
+        }
+        for (const lang of manifest.i18n.languages) {
+            // Validation messages
+            const validationMessages = defaultValidationMessages[lang] || defaultValidationMessages.en;
+            files.push({
+                path: `i18n/${lang}/validation.json`,
+                content: JSON.stringify(validationMessages, null, 2),
+            });
+            // Field labels
+            const fieldLabels = generateFieldLabels(manifest.entities);
+            files.push({
+                path: `i18n/${lang}/fields.json`,
+                content: JSON.stringify(fieldLabels, null, 2),
+            });
+            // Entity names (for UI)
+            const entityNames = {};
+            for (const entity of manifest.entities) {
+                entityNames[entity.name.toLowerCase()] = entity.name;
+            }
+            files.push({
+                path: `i18n/${lang}/entities.json`,
+                content: JSON.stringify(entityNames, null, 2),
+            });
+        }
+        return files;
+    },
+};

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

@@ -0,0 +1,8 @@
+export { schemaGenerator } from './schema';
+export { authGenerator } from './auth';
+export { validationGenerator } from './validation';
+export { apiGenerator } from './api';
+export { hooksGenerator } from './hooks';
+export { crudHooksGenerator } from './crud-hooks';
+export { i18nGenerator } from './i18n';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/templates/nextjs-drizzle-trpc/generators/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,OAAO,CAAA;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA"}

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

@@ -0,0 +1,18 @@
+"use strict";
+// Export all generators for the nextjs-drizzle-trpc template
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nGenerator = exports.crudHooksGenerator = exports.hooksGenerator = exports.apiGenerator = exports.validationGenerator = exports.authGenerator = exports.schemaGenerator = void 0;
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "schemaGenerator", { enumerable: true, get: function () { return schema_1.schemaGenerator; } });
+var auth_1 = require("./auth");
+Object.defineProperty(exports, "authGenerator", { enumerable: true, get: function () { return auth_1.authGenerator; } });
+var validation_1 = require("./validation");
+Object.defineProperty(exports, "validationGenerator", { enumerable: true, get: function () { return validation_1.validationGenerator; } });
+var api_1 = require("./api");
+Object.defineProperty(exports, "apiGenerator", { enumerable: true, get: function () { return api_1.apiGenerator; } });
+var hooks_1 = require("./hooks");
+Object.defineProperty(exports, "hooksGenerator", { enumerable: true, get: function () { return hooks_1.hooksGenerator; } });
+var crud_hooks_1 = require("./crud-hooks");
+Object.defineProperty(exports, "crudHooksGenerator", { enumerable: true, get: function () { return crud_hooks_1.crudHooksGenerator; } });
+var i18n_1 = require("./i18n");
+Object.defineProperty(exports, "i18nGenerator", { enumerable: true, get: function () { return i18n_1.i18nGenerator; } });

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

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

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

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