@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/presets/extend.test.ts

@@ -1,295 +0,0 @@
-/**
- * Preset Extension and Composition Tests
- */
-
-import { describe, expect, it } from 'bun:test'
-import {
-  extendPreset,
-  composePresets,
-  withMonitoring,
-  withSecurity,
-  withDatabase,
-  withCache,
-  withCDN,
-  withQueue,
-} from './extend'
-import type { CloudConfig } from '@stacksjs/ts-cloud-types'
-
-describe('extendPreset', () => {
-  it('should extend base preset with new properties', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Base',
-        slug: 'base',
-        region: 'us-east-1',
-      },
-    }
-
-    const extension: Partial<CloudConfig> = {
-      infrastructure: {
-        storage: {
-          uploads: {},
-        },
-      },
-    }
-
-    const result = extendPreset(base, extension)
-
-    expect(result.project).toEqual(base.project)
-    expect(result.infrastructure?.storage).toEqual(extension.infrastructure?.storage)
-  })
-
-  it('should override base properties with extension properties', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Base',
-        slug: 'base',
-        region: 'us-east-1',
-      },
-    }
-
-    const extension: Partial<CloudConfig> = {
-      project: {
-        name: 'Base',
-        slug: 'base',
-        region: 'eu-west-1',
-      },
-    }
-
-    const result = extendPreset(base, extension)
-
-    expect(result.project?.name).toBe('Base')
-    expect(result.project?.slug).toBe('base')
-    expect(result.project?.region).toBe('eu-west-1')
-  })
-
-  it('should merge infrastructure configurations', () => {
-    const base: Partial<CloudConfig> = {
-      infrastructure: {
-        storage: {
-          uploads: {},
-        },
-      },
-    }
-
-    const extension: Partial<CloudConfig> = {
-      infrastructure: {
-        storage: {
-          assets: {},
-        },
-      },
-    }
-
-    const result = extendPreset(base, extension)
-
-    expect(result.infrastructure?.storage?.uploads).toBeDefined()
-    expect(result.infrastructure?.storage?.assets).toBeDefined()
-  })
-})
-
-describe('composePresets', () => {
-  it('should compose multiple presets in order', () => {
-    const preset1: Partial<CloudConfig> = {
-      project: {
-        name: 'Project',
-        slug: 'project',
-        region: 'us-west-2',
-      },
-    }
-
-    const preset2: Partial<CloudConfig> = {
-      project: {
-        name: 'Project',
-        slug: 'project',
-        region: 'us-east-1',
-      },
-    }
-
-    const preset3: Partial<CloudConfig> = {
-      infrastructure: {
-        storage: {},
-      },
-    }
-
-    const result = composePresets(preset1, preset2, preset3)
-
-    expect(result.project?.name).toBe('Project')
-    expect(result.project?.slug).toBe('project')
-    expect(result.project?.region).toBe('us-east-1')
-    expect(result.infrastructure?.storage).toBeDefined()
-  })
-
-  it('should apply later presets over earlier ones', () => {
-    const preset1: Partial<CloudConfig> = {
-      project: {
-        name: 'Project',
-        slug: 'project',
-        region: 'us-east-1',
-      },
-    }
-
-    const preset2: Partial<CloudConfig> = {
-      project: {
-        name: 'Project',
-        slug: 'project',
-        region: 'eu-west-1',
-      },
-    }
-
-    const result = composePresets(preset1, preset2)
-
-    expect(result.project?.region).toBe('eu-west-1')
-  })
-
-  it('should handle empty presets', () => {
-    const preset1: Partial<CloudConfig> = {
-      project: {
-        name: 'Test',
-        slug: 'test',
-        region: 'us-east-1',
-      },
-    }
-
-    const result = composePresets(preset1, {}, {})
-
-    expect(result.project?.name).toBe('Test')
-  })
-})
-
-describe('withMonitoring', () => {
-  it('should add monitoring configuration', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Test',
-        slug: 'test',
-        region: 'us-east-1',
-      },
-    }
-
-    const result = extendPreset(base, withMonitoring({
-      alarms: [],
-    }))
-
-    expect(result.infrastructure?.monitoring).toBeDefined()
-  })
-
-  it('should preserve existing infrastructure', () => {
-    const base: Partial<CloudConfig> = {
-      infrastructure: {
-        storage: {
-          uploads: {},
-        },
-      },
-    }
-
-    const result = extendPreset(base, withMonitoring({
-      alarms: [],
-    }))
-
-    expect(result.infrastructure?.storage?.uploads).toBeDefined()
-    expect(result.infrastructure?.monitoring).toBeDefined()
-  })
-})
-
-describe('withSecurity', () => {
-  it('should add security configuration', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Test',
-        slug: 'test',
-        region: 'us-east-1',
-      },
-    }
-
-    const result = extendPreset(base, withSecurity({
-      waf: { enabled: true },
-    }))
-
-    expect(result.infrastructure?.security).toBeDefined()
-    expect(result.infrastructure?.security?.waf?.enabled).toBe(true)
-  })
-})
-
-describe('withDatabase', () => {
-  it('should add database configuration', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Test',
-        slug: 'test',
-        region: 'us-east-1',
-      },
-    }
-
-    const result = extendPreset(base, withDatabase({
-      postgres: {
-        instanceClass: 'db.t3.micro',
-      },
-    }))
-
-    expect(result.infrastructure?.databases?.postgres).toBeDefined()
-    expect(result.infrastructure?.databases?.postgres?.instanceClass).toBe('db.t3.micro')
-  })
-})
-
-describe('withCache', () => {
-  it('should add cache configuration', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Test',
-        slug: 'test',
-        region: 'us-east-1',
-      },
-    }
-
-    const result = extendPreset(base, withCache({
-      redis: {
-        nodeType: 'cache.t3.small',
-      },
-    }))
-
-    expect(result.infrastructure?.cache?.redis).toBeDefined()
-    expect(result.infrastructure?.cache?.redis?.nodeType).toBe('cache.t3.small')
-  })
-})
-
-describe('withCDN', () => {
-  it('should add CDN configuration', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Test',
-        slug: 'test',
-        region: 'us-east-1',
-      },
-    }
-
-    const result = extendPreset(base, withCDN({
-      enabled: true,
-      compress: true,
-    }))
-
-    expect(result.infrastructure?.cdn).toBeDefined()
-    expect(result.infrastructure?.cdn?.enabled).toBe(true)
-    expect(result.infrastructure?.cdn?.compress).toBe(true)
-  })
-})
-
-describe('withQueue', () => {
-  it('should add queue configuration', () => {
-    const base: Partial<CloudConfig> = {
-      project: {
-        name: 'Test',
-        slug: 'test',
-        region: 'us-east-1',
-      },
-    }
-
-    const result = extendPreset(base, withQueue({
-      jobs: {
-        fifo: false,
-      },
-    }))
-
-    expect(result.infrastructure?.queues?.jobs).toBeDefined()
-    expect(result.infrastructure?.queues?.jobs?.fifo).toBe(false)
-  })
-})

package/src/presets/extend.ts

@@ -1,297 +0,0 @@
-import type { CloudConfig } from '@stacksjs/ts-cloud-types'
-
-/**
- * Deep merge utility for combining CloudConfig objects
- */
-function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
-  const result = { ...target }
-
-  for (const key in source) {
-    const sourceValue = source[key]
-    const targetValue = result[key]
-
-    if (sourceValue === undefined) {
-      continue
-    }
-
-    if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
-      // Merge arrays by concatenating
-      result[key] = [...targetValue, ...sourceValue] as any
-    }
-    else if (
-      typeof sourceValue === 'object'
-      && sourceValue !== null
-      && !Array.isArray(sourceValue)
-      && typeof targetValue === 'object'
-      && targetValue !== null
-      && !Array.isArray(targetValue)
-    ) {
-      // Recursively merge objects
-      result[key] = deepMerge(targetValue, sourceValue)
-    }
-    else {
-      // Override primitive values
-      result[key] = sourceValue as any
-    }
-  }
-
-  return result
-}
-
-/**
- * Extend a base preset with custom configuration
- *
- * @example
- * ```typescript
- * const myPreset = extendPreset(
- *   createNodeJsServerPreset({ name: 'My App', slug: 'my-app' }),
- *   {
- *     infrastructure: {
- *       compute: {
- *         server: {
- *           instanceType: 't3.large', // Override instance type
- *           autoScaling: {
- *             max: 20, // Increase max instances
- *           },
- *         },
- *       },
- *       database: {
- *         postgres: {
- *           instanceClass: 'db.r6g.xlarge', // Upgrade database
- *         },
- *       },
- *     },
- *   }
- * )
- * ```
- */
-export function extendPreset(
-  basePreset: Partial<CloudConfig>,
-  extensions: Partial<CloudConfig>,
-): Partial<CloudConfig> {
-  return deepMerge(basePreset as Record<string, any>, extensions as Record<string, any>) as Partial<CloudConfig>
-}
-
-/**
- * Compose multiple presets together
- * Later presets override earlier ones
- *
- * @example
- * ```typescript
- * const composedPreset = composePresets(
- *   createStaticSitePreset({ name: 'Site', slug: 'site', domain: 'example.com' }),
- *   createApiBackendPreset({ name: 'API', slug: 'api' }),
- *   {
- *     // Custom overrides
- *     infrastructure: {
- *       monitoring: {
- *         alarms: [{ metric: 'CustomMetric', threshold: 100 }],
- *       },
- *     },
- *   }
- * )
- * ```
- */
-export function composePresets(
-  ...presets: Partial<CloudConfig>[]
-): Partial<CloudConfig> {
-  return presets.reduce(
-    (acc, preset) => deepMerge(acc as Record<string, any>, preset as Record<string, any>),
-    {} as Record<string, any>,
-  ) as Partial<CloudConfig>
-}
-
-/**
- * Create a custom preset by extending an existing one
- *
- * @example
- * ```typescript
- * const createMyCustomPreset = createPreset(
- *   (options) => createNodeJsServerPreset(options),
- *   {
- *     infrastructure: {
- *       monitoring: {
- *         dashboard: {
- *           name: 'custom-dashboard',
- *           widgets: [{ type: 'metric', metrics: ['CustomMetric'] }],
- *         },
- *       },
- *     },
- *   }
- * )
- *
- * // Use it
- * const myPreset = createMyCustomPreset({ name: 'App', slug: 'app' })
- * ```
- */
-export function createPreset<TOptions extends Record<string, any>>(
-  basePresetFn: (options: TOptions) => Partial<CloudConfig>,
-  extensions: Partial<CloudConfig> | ((config: Partial<CloudConfig>, options: TOptions) => Partial<CloudConfig>),
-): (options: TOptions) => Partial<CloudConfig> {
-  return (options: TOptions) => {
-    const baseConfig = basePresetFn(options)
-
-    if (typeof extensions === 'function') {
-      return extendPreset(baseConfig, extensions(baseConfig, options))
-    }
-
-    return extendPreset(baseConfig, extensions)
-  }
-}
-
-/**
- * Merge infrastructure configurations selectively
- * Useful for adding specific infrastructure to existing presets
- *
- * @example
- * ```typescript
- * const withRedis = mergeInfrastructure({
- *   cache: {
- *     redis: {
- *       nodeType: 'cache.t3.small',
- *       numCacheNodes: 2,
- *     },
- *   },
- * })
- *
- * const myPreset = extendPreset(
- *   createApiBackendPreset({ name: 'API', slug: 'api' }),
- *   withRedis
- * )
- * ```
- */
-export function mergeInfrastructure(
-  infrastructure: Partial<CloudConfig['infrastructure']>,
-): Partial<CloudConfig> {
-  return {
-    infrastructure,
-  }
-}
-
-/**
- * Add monitoring configuration to any preset
- *
- * @example
- * ```typescript
- * const myPreset = extendPreset(
- *   createStaticSitePreset({ name: 'Site', slug: 'site' }),
- *   withMonitoring({
- *     dashboard: { name: 'my-dashboard' },
- *     alarms: [{ metric: 'Errors', threshold: 10 }],
- *   })
- * )
- * ```
- */
-export function withMonitoring(
-  monitoring: NonNullable<CloudConfig['infrastructure']>['monitoring'],
-): Partial<CloudConfig> {
-  return mergeInfrastructure({ monitoring })
-}
-
-/**
- * Add security configuration to any preset
- *
- * @example
- * ```typescript
- * const myPreset = extendPreset(
- *   createApiBackendPreset({ name: 'API', slug: 'api' }),
- *   withSecurity({
- *     waf: { enabled: true, rules: ['rateLimit', 'sqlInjection'] },
- *   })
- * )
- * ```
- */
-export function withSecurity(
-  security: NonNullable<CloudConfig['infrastructure']>['security'],
-): Partial<CloudConfig> {
-  return mergeInfrastructure({ security })
-}
-
-/**
- * Add database configuration to any preset
- *
- * @example
- * ```typescript
- * const myPreset = extendPreset(
- *   createNodeJsServerlessPreset({ name: 'App', slug: 'app' }),
- *   withDatabase({
- *     postgres: {
- *       engine: 'postgres',
- *       version: '15',
- *       instanceClass: 'db.t3.medium',
- *       multiAZ: true,
- *     },
- *   })
- * )
- * ```
- */
-export function withDatabase(
-  databases: NonNullable<CloudConfig['infrastructure']>['databases'],
-): Partial<CloudConfig> {
-  return mergeInfrastructure({ databases })
-}
-
-/**
- * Add cache configuration to any preset
- *
- * @example
- * ```typescript
- * const myPreset = extendPreset(
- *   createApiBackendPreset({ name: 'API', slug: 'api' }),
- *   withCache({
- *     redis: {
- *       nodeType: 'cache.t3.small',
- *       numCacheNodes: 2,
- *     },
- *   })
- * )
- * ```
- */
-export function withCache(
-  cache: NonNullable<CloudConfig['infrastructure']>['cache'],
-): Partial<CloudConfig> {
-  return mergeInfrastructure({ cache })
-}
-
-/**
- * Add CDN configuration to any preset
- *
- * @example
- * ```typescript
- * const myPreset = extendPreset(
- *   createNodeJsServerPreset({ name: 'App', slug: 'app' }),
- *   withCDN({
- *     enabled: true,
- *     compress: true,
- *     http3: true,
- *   })
- * )
- * ```
- */
-export function withCDN(
-  cdn: NonNullable<CloudConfig['infrastructure']>['cdn'],
-): Partial<CloudConfig> {
-  return mergeInfrastructure({ cdn })
-}
-
-/**
- * Add queue configuration to any preset
- *
- * @example
- * ```typescript
- * const myPreset = extendPreset(
- *   createNodeJsServerlessPreset({ name: 'App', slug: 'app' }),
- *   withQueue({
- *     jobs: {
- *       fifo: false,
- *       deadLetterQueue: true,
- *     },
- *   })
- * )
- * ```
- */
-export function withQueue(
-  queues: NonNullable<CloudConfig['infrastructure']>['queues'],
-): Partial<CloudConfig> {
-  return mergeInfrastructure({ queues })
-}