@tanstack/create 0.49.1

package/src/utils.ts

@@ -0,0 +1,42 @@
+export function sortObject(
+  obj: Record<string, string>,
+): Record<string, string> {
+  return Object.keys(obj)
+    .sort()
+    .reduce<Record<string, string>>((acc, key) => {
+      acc[key] = obj[key]
+      return acc
+    }, {})
+}
+
+export function jsSafeName(name: string) {
+  return name
+    .split(/[^a-zA-Z0-9]/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('')
+}
+
+export function formatCommand({
+  command,
+  args,
+}: {
+  command: string
+  args: Array<string>
+}) {
+  return `${command} ${args.join(' ')}`.trim()
+}
+
+// Turn GitHub URLs into raw URLs
+export function handleSpecialURL(url: string) {
+  if (url.startsWith('https://github.com/') && url.includes('blob')) {
+    return url
+      .replace('https://github.com/', 'https://raw.githubusercontent.com/')
+      .replace('/blob/', '/refs/heads/')
+  }
+  if (url.startsWith('https://github.com/') && url.includes('tree')) {
+    return url
+      .replace('https://github.com/', 'https://raw.githubusercontent.com/')
+      .replace('/tree/', '/refs/heads/')
+  }
+  return url
+}

package/tests/add-on-options.test.ts

@@ -0,0 +1,332 @@
+import { describe, expect, it } from 'vitest'
+import { populateAddOnOptionsDefaults } from '../src/add-ons.js'
+import { AddOnOptionSchema, AddOnOptionsSchema, AddOnSelectOptionSchema } from '../src/types.js'
+import type { AddOn } from '../src/types.js'
+
+// Helper function to create test AddOn objects
+function createTestAddOn(overrides: Partial<AddOn>): AddOn {
+  return {
+    id: 'test-addon',
+    name: 'Test Addon',
+    description: 'Test addon description',
+    type: 'add-on',
+    modes: ['file-router'],
+    phase: 'add-on',
+    files: {},
+    deletedFiles: [],
+    getFiles: () => Promise.resolve([]),
+    getFileContents: () => Promise.resolve(''),
+    getDeletedFiles: () => Promise.resolve([]),
+    ...overrides
+  }
+}
+
+describe('Add-on Options', () => {
+  describe('Option Schema Validation', () => {
+    it('should validate a valid select option', () => {
+      const validSelectOption = {
+        type: 'select',
+        label: 'Database Provider',
+        description: 'Choose your database provider',
+        default: 'postgres',
+        options: [
+          { value: 'postgres', label: 'PostgreSQL' },
+          { value: 'mysql', label: 'MySQL' },
+          { value: 'sqlite', label: 'SQLite' }
+        ]
+      }
+
+      expect(() => AddOnSelectOptionSchema.parse(validSelectOption)).not.toThrow()
+    })
+
+    it('should reject select option without required fields', () => {
+      const invalidSelectOption = {
+        type: 'select',
+        // Missing required 'label' field
+        options: [{ value: 'test', label: 'Test' }]
+      }
+
+      expect(() => AddOnSelectOptionSchema.parse(invalidSelectOption)).toThrow()
+    })
+
+    it('should reject select option with invalid option format', () => {
+      const invalidSelectOption = {
+        type: 'select',
+        label: 'Test',
+        options: [
+          { value: 'test' } // Missing 'label' field
+        ]
+      }
+
+      expect(() => AddOnSelectOptionSchema.parse(invalidSelectOption)).toThrow()
+    })
+
+    it('should reject select option with empty options array', () => {
+      const invalidSelectOption = {
+        type: 'select',
+        label: 'Test',
+        options: []
+      }
+
+      expect(() => AddOnSelectOptionSchema.parse(invalidSelectOption)).toThrow()
+    })
+
+    it('should validate AddOnOption discriminated union', () => {
+      const validOption = {
+        type: 'select',
+        label: 'Theme',
+        default: 'dark',
+        options: [
+          { value: 'dark', label: 'Dark' },
+          { value: 'light', label: 'Light' }
+        ]
+      }
+
+      expect(() => AddOnOptionSchema.parse(validOption)).not.toThrow()
+    })
+
+    it('should validate AddOnOptions record', () => {
+      const validOptions = {
+        database: {
+          type: 'select',
+          label: 'Database Provider',
+          default: 'postgres',
+          options: [
+            { value: 'postgres', label: 'PostgreSQL' },
+            { value: 'mysql', label: 'MySQL' }
+          ]
+        },
+        theme: {
+          type: 'select',
+          label: 'Theme',
+          default: 'dark',
+          options: [
+            { value: 'dark', label: 'Dark' },
+            { value: 'light', label: 'Light' }
+          ]
+        }
+      }
+
+      expect(() => AddOnOptionsSchema.parse(validOptions)).not.toThrow()
+    })
+  })
+
+  describe('populateAddOnOptionsDefaults', () => {
+    it('should populate defaults for add-ons with options', () => {
+      const addOns = [
+        createTestAddOn({
+          id: 'testAddon',
+          name: 'Test Addon',
+          options: {
+            database: {
+              type: 'select' as const,
+              label: 'Database Provider',
+              default: 'postgres',
+              options: [
+                { value: 'postgres', label: 'PostgreSQL' },
+                { value: 'mysql', label: 'MySQL' },
+                { value: 'sqlite', label: 'SQLite' }
+              ]
+            }
+          }
+        }),
+        createTestAddOn({
+          id: 'shadcn',
+          name: 'shadcn/ui',
+          options: {
+            theme: {
+              type: 'select' as const,
+              label: 'Theme',
+              default: 'neutral',
+              options: [
+                { value: 'neutral', label: 'Neutral' },
+                { value: 'slate', label: 'Slate' }
+              ]
+            }
+          }
+        })
+      ]
+
+      const result = populateAddOnOptionsDefaults(addOns)
+
+      expect(result).toEqual({
+        testAddon: {
+          database: 'postgres'
+        },
+        shadcn: {
+          theme: 'neutral'
+        }
+      })
+    })
+
+    it('should handle add-ons without options', () => {
+      const addOns = [
+        createTestAddOn({
+          id: 'simple-addon',
+          name: 'Simple Add-on'
+          // No options property
+        })
+      ]
+
+      const result = populateAddOnOptionsDefaults(addOns)
+
+      expect(result).toEqual({})
+    })
+
+    it('should only populate defaults for enabled add-ons', () => {
+      const addOns = [
+        createTestAddOn({
+          id: 'testAddon',
+          name: 'Test Addon',
+          options: {
+            database: {
+              type: 'select' as const,
+              label: 'Database Provider',
+              default: 'postgres',
+              options: [
+                { value: 'postgres', label: 'PostgreSQL' },
+                { value: 'mysql', label: 'MySQL' }
+              ]
+            }
+          }
+        }),
+        createTestAddOn({
+          id: 'shadcn',
+          name: 'shadcn/ui',
+          options: {
+            theme: {
+              type: 'select' as const,
+              label: 'Theme',
+              default: 'neutral',
+              options: [
+                { value: 'neutral', label: 'Neutral' },
+                { value: 'slate', label: 'Slate' }
+              ]
+            }
+          }
+        })
+      ]
+
+      const enabledAddOns = [addOns[0]] // Only testAddon
+      const result = populateAddOnOptionsDefaults(enabledAddOns)
+
+      expect(result).toEqual({
+        testAddon: {
+          database: 'postgres'
+        }
+        // shadcn should not be included
+      })
+    })
+
+    it('should handle empty enabled add-ons array', () => {
+      const enabledAddOns: Array<any> = []
+      const result = populateAddOnOptionsDefaults(enabledAddOns)
+
+      expect(result).toEqual({})
+    })
+
+    it('should handle add-ons with multiple options', () => {
+      const addOns = [
+        createTestAddOn({
+          id: 'complex-addon',
+          name: 'Complex Add-on',
+          options: {
+            database: {
+              type: 'select' as const,
+              label: 'Database',
+              default: 'postgres',
+              options: [
+                { value: 'postgres', label: 'PostgreSQL' },
+                { value: 'mysql', label: 'MySQL' }
+              ]
+            },
+            theme: {
+              type: 'select' as const,
+              label: 'Theme',
+              default: 'dark',
+              options: [
+                { value: 'dark', label: 'Dark' },
+                { value: 'light', label: 'Light' }
+              ]
+            }
+          }
+        })
+      ]
+
+      const result = populateAddOnOptionsDefaults(addOns)
+
+      expect(result).toEqual({
+        'complex-addon': {
+          database: 'postgres',
+          theme: 'dark'
+        }
+      })
+    })
+
+    it('should handle options without default values', () => {
+      const addOns = [
+        createTestAddOn({
+          id: 'no-default',
+          name: 'No Default Add-on',
+          options: {
+            database: {
+              type: 'select' as const,
+              label: 'Database',
+              default: 'postgres', // We need a default for valid schema
+              options: [
+                { value: 'postgres', label: 'PostgreSQL' },
+                { value: 'mysql', label: 'MySQL' }
+              ]
+            }
+          }
+        })
+      ]
+
+      // Test the case where an addon has no default by manually modifying the option
+      if (addOns[0].options?.database) {
+        delete (addOns[0].options.database as any).default
+      }
+
+      const result = populateAddOnOptionsDefaults(addOns)
+
+      expect(result).toEqual({
+        'no-default': {
+          database: undefined
+        }
+      })
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('should handle malformed option definitions gracefully', () => {
+      const malformedOptions = {
+        invalid: {
+          type: 'unknown-type', // Invalid type
+          label: 'Test'
+        }
+      }
+
+      expect(() => AddOnOptionsSchema.parse(malformedOptions)).toThrow()
+    })
+
+    it('should validate option value types', () => {
+      const invalidOption = {
+        type: 'select',
+        label: 123, // Should be string
+        options: [{ value: 'test', label: 'Test' }]
+      }
+
+      expect(() => AddOnSelectOptionSchema.parse(invalidOption)).toThrow()
+    })
+
+    it('should require non-empty option arrays', () => {
+      const emptyOptionsArray = {
+        type: 'select',
+        label: 'Test',
+        options: []
+      }
+
+      expect(() => AddOnSelectOptionSchema.parse(emptyOptionsArray)).toThrow()
+    })
+  })
+})

package/tests/add-ons.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest'
+
+import { finalizeAddOns, getAllAddOns } from '../src/add-ons.js'
+
+import type { AddOn, Framework } from '../src/types.js'
+
+describe('getAllAddOns', () => {
+  it('filter add-ons', () => {
+    const addOns = getAllAddOns(
+      {
+        id: 'react-cra',
+        getAddOns: () => [
+          {
+            id: 'add-on-1',
+            description: 'Add-on 1',
+            modes: ['file-router'],
+          } as AddOn,
+          {
+            id: 'add-on-2',
+            description: 'Add-on 2',
+            modes: ['code-router'],
+          } as AddOn,
+        ],
+      } as Framework,
+      'file-router',
+    )
+
+    expect(addOns.length).toEqual(1)
+    expect(addOns[0].id).toEqual('add-on-1')
+  })
+
+  it('should sort add-ons by priority (higher priority first)', () => {
+    const addOns = getAllAddOns(
+      {
+        id: 'react-cra',
+        getAddOns: () => [
+          {
+            id: 'low-priority',
+            description: 'Low Priority',
+            modes: ['file-router'],
+            priority: 10,
+          } as AddOn,
+          {
+            id: 'high-priority',
+            description: 'High Priority',
+            modes: ['file-router'],
+            priority: 100,
+          } as AddOn,
+          {
+            id: 'no-priority',
+            description: 'No Priority (defaults to 0)',
+            modes: ['file-router'],
+          } as AddOn,
+          {
+            id: 'medium-priority',
+            description: 'Medium Priority',
+            modes: ['file-router'],
+            priority: 50,
+          } as AddOn,
+        ],
+      } as Framework,
+      'file-router',
+    )
+
+    expect(addOns.length).toEqual(4)
+    expect(addOns[0].id).toEqual('high-priority')
+    expect(addOns[1].id).toEqual('medium-priority')
+    expect(addOns[2].id).toEqual('low-priority')
+    expect(addOns[3].id).toEqual('no-priority')
+  })
+
+  it('should filter by mode and then sort by priority', () => {
+    const addOns = getAllAddOns(
+      {
+        id: 'react-cra',
+        getAddOns: () => [
+          {
+            id: 'file-router-low',
+            description: 'File Router Low',
+            modes: ['file-router'],
+            priority: 20,
+          } as AddOn,
+          {
+            id: 'code-router-high',
+            description: 'Code Router High (should be filtered out)',
+            modes: ['code-router'],
+            priority: 200,
+          } as AddOn,
+          {
+            id: 'file-router-high',
+            description: 'File Router High',
+            modes: ['file-router'],
+            priority: 100,
+          } as AddOn,
+        ],
+      } as Framework,
+      'file-router',
+    )
+
+    expect(addOns.length).toEqual(2)
+    expect(addOns[0].id).toEqual('file-router-high')
+    expect(addOns[1].id).toEqual('file-router-low')
+  })
+})
+
+describe('finalizeAddOns', () => {
+  it('should finalize add-ons', async () => {
+    const addOns = await finalizeAddOns(
+      {
+        id: 'react-cra',
+        getAddOns: () => [
+          {
+            id: 'add-on-1',
+            description: 'Add-on 1',
+            modes: ['file-router'],
+            dependsOn: ['add-on-2'],
+          } as AddOn,
+          {
+            id: 'add-on-2',
+            description: 'Add-on 2',
+            modes: ['file-router'],
+          } as AddOn,
+          {
+            id: 'add-on-3',
+            description: 'Add-on 3',
+            modes: ['file-router'],
+          } as AddOn,
+        ],
+      } as Framework,
+      'file-router',
+      ['add-on-1'],
+    )
+
+    expect(addOns.length).toEqual(2)
+    const addOnIds = addOns.map((a) => a.id)
+    expect(addOnIds.includes('add-on-1')).toEqual(true)
+    expect(addOnIds.includes('add-on-2')).toEqual(true)
+    expect(addOnIds.includes('add-on-3')).toEqual(false)
+  })
+})