@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/cli/repl.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Interactive REPL mode for ts-cloud CLI
+ * Provides a shell-like experience for running commands
+ */
+export declare interface REPLOptions {
+  prompt?: string
+  welcome?: string
+  commands: Map<string, REPLCommand>
+  historyFile?: string
+  autocomplete?: boolean
+}
+export declare interface REPLCommand {
+  name: string
+  description: string
+  aliases?: string[]
+  handler: (args: string[]) => Promise<void> | void
+  autocomplete?: (partial: string) => string[]
+}
+export declare interface REPLHistory {
+  commands: string[]
+  maxSize: number
+}
+/**
+ * REPL session manager
+ */
+export declare class REPL {
+  private options: REPLOptions;
+  private running: boolean;
+  private history: REPLHistory;
+  private historyIndex: number;
+  constructor(options: REPLOptions);
+  start(): Promise<void>;
+  stop(): void;
+  private readInput(): Promise<string>;
+  private executeCommand(input: string): Promise<void>;
+  private parseCommand(input: string): string[];
+  private findCommand(name: string): REPLCommand | undefined;
+  private showHelp(): void;
+  private showHistory(): void;
+  private addToHistory(command: string): void;
+  private historyBack(): string | undefined;
+  private historyForward(): string | undefined;
+  private autocomplete(partial: string): string[];
+  private loadHistory(): Promise<void>;
+  private saveHistory(): Promise<void>;
+  searchHistory(query: string): string[];
+  clearHistory(): void;
+}
+/**
+ * Context manager for REPL sessions
+ * Maintains state across commands
+ */
+export declare class REPLContext {
+  private variables: Map<string, any>;
+  private workingDirectory: string;
+  set(key: string, value: any): void;
+  get(key: string): any;
+  has(key: string): boolean;
+  delete(key: string): void;
+  getAll(): Record<string, any>;
+  clear(): void;
+  setWorkingDirectory(path: string): void;
+  getWorkingDirectory(): string;
+}
+/**
+ * Command builder for creating REPL commands
+ */
+export declare class REPLCommandBuilder {
+  private command: Partial<REPLCommand>;
+  name(name: string): this;
+  description(description: string): this;
+  aliases(aliases: string[]): this;
+  handler(handler: (args: string[]) => Promise<void> | void): this;
+  autocomplete(fn: (partial: string) => string[]): this;
+  build(): REPLCommand;
+}

package/dist/cli/suggestions.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Suggest similar commands based on typo
+ */
+export declare function suggestCommand(input: string, availableCommands: string[], threshold?: any): string[];
+/**
+ * Format suggestion message
+ */
+export declare function formatSuggestion(input: string, suggestions: string[]): string;
+/**
+ * Check if input is likely a typo of any available command
+ */
+export declare function isLikelyTypo(input: string, availableCommands: string[]): boolean;
+/**
+ * Get contextual help based on current command
+ */
+export declare function getContextualHelp(currentCommand: string, categories: CommandCategory[]): string;
+/**
+ * Search commands by keyword
+ */
+export declare function searchCommands(query: string, categories: CommandCategory[]): Array<{ command: CommandInfo; category: string }>;
+/**
+ * Autocomplete suggestions for partial input
+ */
+export declare function autocomplete(partial: string, availableCommands: string[], maxResults?: any): string[];
+export declare function suggestFlags(partial: string, availableFlags: FlagInfo[]): FlagInfo[];
+/**
+ * Format flag suggestions
+ */
+export declare function formatFlagSuggestions(flags: FlagInfo[]): string;
+/**
+ * Get command usage example
+ */
+export declare function getCommandUsage(command: CommandInfo): string;
+export declare function validateCommand(input: string, availableCommands: string[], requiredFlags?: string[]): ValidationResult;
+/**
+ * Command categories for contextual help
+ */
+export declare interface CommandCategory {
+  name: string
+  description: string
+  commands: CommandInfo[]
+}
+export declare interface CommandInfo {
+  name: string
+  description: string
+  aliases?: string[]
+  examples?: string[]
+}
+/**
+ * Suggest flags based on partial input
+ */
+export declare interface FlagInfo {
+  name: string
+  alias?: string
+  description: string
+  type: 'boolean' | 'string' | 'number'
+  required?: boolean
+}
+/**
+ * Validate command and suggest fixes
+ */
+export declare interface ValidationResult {
+  valid: boolean
+  errors: string[]
+  warnings: string[]
+  suggestions: string[]
+}

package/dist/cli/table.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Format data as a table
+ */
+export declare function formatTable(options: TableOptions): string;
+/**
+ * Format data as a tree
+ */
+export declare function formatTree(nodes: TreeNode[], options?: TreeOptions): string;
+/**
+ * Format a progress bar
+ */
+export declare function formatProgressBar(options: ProgressBarOptions): string;
+/**
+ * Format bytes as human-readable size
+ */
+export declare function formatBytes(bytes: number, decimals?: any): string;
+/**
+ * Format duration as human-readable time
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Format list with bullets
+ */
+export declare function formatList(items: string[], bullet?: any): string;
+/**
+ * Format key-value pairs
+ */
+export declare function formatKeyValue(data: Record<string, any>, options?: { indent?: string; separator?: string }): string;
+/**
+ * Table formatting utilities for CLI output
+ * Better table rendering with borders, alignment, colors
+ */
+export declare interface TableColumn {
+  key: string
+  label: string
+  width?: number
+  align?: 'left' | 'right' | 'center'
+  formatter?: (value: any) => string
+}
+export declare interface TableOptions {
+  columns: TableColumn[]
+  data: Record<string, any>[]
+  border?: boolean
+  header?: boolean
+  compact?: boolean
+  maxWidth?: number
+}
+/**
+ * Format data as a tree structure
+ */
+export declare interface TreeNode {
+  label: string
+  children?: TreeNode[]
+  metadata?: Record<string, any>
+}
+export declare interface TreeOptions {
+  indent?: string
+  showMetadata?: boolean
+}
+/**
+ * Create a simple progress bar
+ */
+export declare interface ProgressBarOptions {
+  total: number
+  current: number
+  width?: number
+  format?: string
+  complete?: string
+  incomplete?: string
+}

package/dist/cloudformation/builder.d.ts

@@ -0,0 +1,59 @@
+import { addApiGatewayResources } from './builders/api-gateway';
+import { addCacheResources } from './builders/cache';
+import { addCDNResources } from './builders/cdn';
+import { addComputeResources } from './builders/compute';
+import { addDatabaseResources } from './builders/database';
+import { addFunctionResources } from './builders/functions';
+import { addMessagingResources } from './builders/messaging';
+import { addMonitoringResources } from './builders/monitoring';
+import { addNetworkResources } from './builders/network';
+import { addQueueResources } from './builders/queue';
+import { addSecurityResources } from './builders/security';
+import { addStorageResources } from './builders/storage';
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+import type { CloudFormationTemplate, CloudFormationResource } from './types';
+/**
+ * Main function to convert CloudConfig to CloudFormation template
+ */
+export declare function buildCloudFormationTemplate(config: CloudConfig): CloudFormationTemplate;
+/**
+ * CloudFormation Template Builder
+ * Converts-cloudConfig to CloudFormation templates
+ */
+export declare class CloudFormationBuilder {
+  protected template: CloudFormationTemplate;
+  private config: CloudConfig;
+  private resourceDependencies: Map<string, Set<string>>;
+  constructor(config: CloudConfig);
+  build(): CloudFormationTemplate;
+  private addParameters(): void;
+  private addMappings(): void;
+  private addConditions(): void;
+  private addResources(): void;
+  private initializeOutputs(): void;
+  addResource(logicalId: string, type: string, properties: Record<string, any>, options?: {
+      dependsOn?: string | string[]
+      condition?: string
+      deletionPolicy?: 'Delete' | 'Retain' | 'Snapshot'
+      updateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot'
+    }): void;
+  addOutputs(outputs: Record<string, any>): void;
+  getOutputs(): Record<string, any>;
+  hasResource(logicalId: string): boolean;
+  getResource(logicalId: string): CloudFormationResource | undefined;
+  private trackDependency(resource: string, dependencies: string | string[]): void;
+  private resolveDependencies(): void;
+  toLogicalId(name: string): string;
+  private addNetworkResources(network: any): void;
+  private addStorageResources(storage: any): void;
+  private addComputeResources(compute: any): void;
+  private addDatabaseResources(database: any): void;
+  private addFunctionResources(functions: any): void;
+  private addCacheResources(cache: any): void;
+  private addQueueResources(queue: any): void;
+  private addMessagingResources(messaging: any): void;
+  private addCDNResources(cdn: any): void;
+  private addApiGatewayResources(apiGateway: any): void;
+  private addMonitoringResources(monitoring: any): void;
+  private addSecurityResources(security: any): void;
+}

package/dist/cloudformation/builders/api-gateway.d.ts

@@ -0,0 +1,30 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add API Gateway resources to CloudFormation template
+ */
+export declare function addApiGatewayResources(builder: CloudFormationBuilder, config: ApiGatewayConfig): void;
+export declare interface ApiGatewayConfig {
+  type: 'http' | 'rest' | 'websocket'
+  customDomain?: {
+    domain: string
+    certificateArn: string
+  }
+  cors?: {
+    allowOrigins: string[]
+    allowMethods: string[]
+    allowHeaders?: string[]
+    maxAge?: number
+  }
+  throttling?: {
+    rateLimit: number
+    burstLimit: number
+  }
+  routes?: any
+  authorizer?: {
+    type: 'jwt' | 'lambda' | 'cognito'
+    identitySource?: string
+    authorizerUri?: string
+    issuer?: string
+    audience?: string[]
+  }
+}

package/dist/cloudformation/builders/cache.d.ts

@@ -0,0 +1,35 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add ElastiCache resources to CloudFormation template
+ */
+export declare function addCacheResources(builder: CloudFormationBuilder, config: CacheConfig): void;
+export declare interface CacheConfig {
+  redis?: {
+    nodeType: string
+    numCacheNodes: number
+    engine: 'redis'
+    engineVersion: string
+    port?: number
+    parameterGroup?: {
+      maxmemoryPolicy?: string
+      timeout?: string
+      [key: string]: string | undefined
+    }
+    snapshotRetentionLimit?: number
+    snapshotWindow?: string
+    automaticFailoverEnabled?: boolean
+  }
+  memcached?: {
+    nodeType: string
+    numCacheNodes: number
+    engine: 'memcached'
+    engineVersion: string
+    port?: number
+  }
+  elasticache?: {
+    nodeType: string
+    numCacheNodes: number
+    engine: string
+    engineVersion: string
+  }
+}

package/dist/cloudformation/builders/cdn.d.ts

@@ -0,0 +1,34 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add CloudFront distribution to CloudFormation template
+ */
+export declare function addCDNResources(builder: CloudFormationBuilder, config: CDNConfig): void;
+export declare interface CDNConfig {
+  enabled: boolean
+  origins?: Array<{
+    id: string
+    domainName: string
+    pathPattern?: string
+    originPath?: string
+  }>
+  customDomain?: {
+    domain: string
+    certificateArn: string
+  }
+  cachePolicy?: {
+    minTTL?: number
+    defaultTTL?: number
+    maxTTL?: number
+  }
+  compress?: boolean
+  http3?: boolean
+  errorPages?: {
+    [code: string]: string
+  }
+  edgeFunctions?: Array<{
+    eventType: 'viewer-request' | 'viewer-response' | 'origin-request' | 'origin-response'
+    functionArn: string
+    name: string
+  }>
+  priceClass?: 'PriceClass_All' | 'PriceClass_200' | 'PriceClass_100'
+}

package/dist/cloudformation/builders/compute.d.ts

@@ -0,0 +1,66 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add compute resources (EC2, ECS, ALB) to CloudFormation template
+ */
+export declare function addComputeResources(builder: CloudFormationBuilder, config: ComputeConfig): void;
+export declare interface LoadBalancerConfig {
+  type: 'application' | 'network'
+  healthCheck?: {
+    path?: string
+    interval?: number
+    timeout?: number
+    healthyThreshold?: number
+    unhealthyThreshold?: number
+  }
+  stickySession?: {
+    enabled: boolean
+    duration?: number
+  }
+}
+export declare interface ServerConfig {
+  instanceType: string
+  ami?: string
+  autoScaling?: {
+    min: number
+    max: number
+    targetCPU?: number
+    scaleUpCooldown?: number
+    scaleDownCooldown?: number
+  }
+  loadBalancer?: LoadBalancerConfig
+  userData?: string
+}
+export declare interface ComputeConfig {
+  server?: ServerConfig
+  fargate?: {
+    taskDefinition: {
+      cpu: string
+      memory: string
+      containerDefinitions?: Array<{
+        name: string
+        image: string
+        portMappings?: Array<{ containerPort: number }>
+        environment?: Record<string, string>
+        healthCheck?: any
+      }>
+    }
+    service: {
+      desiredCount: number
+      serviceDiscovery?: {
+        enabled: boolean
+        namespace?: string
+      }
+      autoScaling?: {
+        min: number
+        max: number
+        targetCPU?: number
+      }
+    }
+  }
+  services?: Array<{
+    name: string
+    type: 'fargate' | 'ec2'
+    taskDefinition: any
+    service: any
+  }>
+}

package/dist/cloudformation/builders/database.d.ts

@@ -0,0 +1,61 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add database resources (RDS, DynamoDB) to CloudFormation template
+ */
+export declare function addDatabaseResources(builder: CloudFormationBuilder, config: DatabaseConfig): void;
+export declare interface DatabaseConfig {
+  postgres?: {
+    engine: 'postgres'
+    version: string
+    instanceClass: string
+    allocatedStorage: number
+    maxAllocatedStorage?: number
+    multiAZ?: boolean
+    backupRetentionDays?: number
+    preferredBackupWindow?: string
+    preferredMaintenanceWindow?: string
+    enablePerformanceInsights?: boolean
+    performanceInsightsRetention?: number
+    deletionProtection?: boolean
+    parameters?: Record<string, string>
+  }
+  mysql?: {
+    engine: 'mysql'
+    version: string
+    instanceClass: string
+    allocatedStorage: number
+    maxAllocatedStorage?: number
+    multiAZ?: boolean
+    backupRetentionDays?: number
+    preferredBackupWindow?: string
+    preferredMaintenanceWindow?: string
+    enablePerformanceInsights?: boolean
+    performanceInsightsRetention?: number
+    deletionProtection?: boolean
+    parameters?: Record<string, string>
+  }
+  dynamodb?: {
+    tables: DynamoDBTableConfig[]
+  }
+}
+export declare interface DynamoDBTableConfig {
+  name: string
+  partitionKey: string
+  sortKey?: string
+  billingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST'
+  readCapacity?: number
+  writeCapacity?: number
+  streamEnabled?: boolean
+  pointInTimeRecovery?: boolean
+  ttl?: {
+    enabled: boolean
+    attributeName: string
+  }
+  globalSecondaryIndexes?: Array<{
+    name: string
+    partitionKey: string
+    sortKey?: string
+    projectionType?: 'ALL' | 'KEYS_ONLY' | 'INCLUDE'
+    nonKeyAttributes?: string[]
+  }>
+}

package/dist/cloudformation/builders/functions.d.ts

@@ -0,0 +1,32 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add Lambda function resources to CloudFormation template
+ */
+export declare function addFunctionResources(builder: CloudFormationBuilder, config: FunctionsConfig): void;
+export declare interface FunctionEvent {
+  type: 'http' | 's3' | 'sqs' | 'sns' | 'kinesis' | 'dynamodb-stream' | 'schedule'
+  path?: string
+  method?: string
+  bucket?: string
+  filterPrefix?: string
+  filterSuffix?: string
+  queueName?: string
+  streamName?: string
+  tableName?: string
+  batchSize?: number
+  startingPosition?: 'LATEST' | 'TRIM_HORIZON'
+  parallelizationFactor?: number
+  expression?: string
+}
+export declare interface FunctionItem {
+  name: string
+  runtime: string
+  handler: string
+  memory: number
+  timeout: number
+  events?: FunctionEvent[]
+  environment?: Record<string, string>
+}
+export declare interface FunctionsConfig {
+
+}

package/dist/cloudformation/builders/messaging.d.ts

@@ -0,0 +1,17 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add SNS topic resources to CloudFormation template
+ */
+export declare function addMessagingResources(builder: CloudFormationBuilder, config: MessagingConfig): void;
+export declare interface TopicConfig {
+  name: string
+  displayName?: string
+  subscriptions?: Array<{
+    protocol: 'http' | 'https' | 'email' | 'email-json' | 'sms' | 'sqs' | 'lambda'
+    endpoint: string
+    filterPolicy?: Record<string, any>
+  }>
+}
+export declare interface MessagingConfig {
+  topics?: TopicConfig[]
+}

package/dist/cloudformation/builders/monitoring.d.ts

@@ -0,0 +1,36 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add CloudWatch monitoring resources to CloudFormation template
+ */
+export declare function addMonitoringResources(builder: CloudFormationBuilder, config: MonitoringConfig): void;
+export declare interface AlarmConfig {
+  name?: string
+  metric: string
+  threshold: number
+  evaluationPeriods?: number
+  comparisonOperator?: 'GreaterThanThreshold' | 'LessThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanOrEqualToThreshold'
+  statistic?: 'Average' | 'Sum' | 'Minimum' | 'Maximum' | 'SampleCount'
+  period?: number
+  treatMissingData?: 'breaching' | 'notBreaching' | 'ignore' | 'missing'
+  service?: string
+  namespace?: string
+  dimensions?: Record<string, string>
+}
+export declare interface MonitoringConfig {
+  dashboard?: {
+    name: string
+    widgets?: Array<{
+      type: 'metric' | 'log' | 'text'
+      metrics?: string[] | Array<{ service?: string, metric: string }>
+      logGroup?: string
+      text?: string
+      width?: number
+      height?: number
+    }>
+  }
+  alarms?: AlarmConfig[]
+  logs?: {
+    retention?: number
+    groups?: string[]
+  }
+}

package/dist/cloudformation/builders/network.d.ts

@@ -0,0 +1,14 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add VPC and networking resources to CloudFormation template
+ */
+export declare function addNetworkResources(builder: CloudFormationBuilder, config: NetworkConfig): void;
+export declare interface NetworkConfig {
+  vpc?: {
+    cidr?: string
+    availabilityZones?: number
+    natGateways?: number
+    enableDnsHostnames?: boolean
+    enableDnsSupport?: boolean
+  }
+}

package/dist/cloudformation/builders/queue.d.ts

@@ -0,0 +1,8 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add SQS queue resources to CloudFormation template
+ */
+export declare function addQueueResources(builder: CloudFormationBuilder, config: QueueConfig): void;
+export declare interface QueueConfig {
+
+}

package/dist/cloudformation/builders/security.d.ts

@@ -0,0 +1,31 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add security resources (ACM certificates, WAF, security groups) to CloudFormation template
+ */
+export declare function addSecurityResources(builder: CloudFormationBuilder, config: SecurityConfig): void;
+export declare interface SecurityConfig {
+  certificate?: {
+    domain: string
+    subdomains?: string[]
+    validationMethod?: 'DNS' | 'EMAIL'
+  }
+  waf?: {
+    enabled: boolean
+    rules?: string[]
+    rateLimit?: number
+    scope?: 'REGIONAL' | 'CLOUDFRONT'
+  }
+  securityGroups?: Record<string, {
+    ingress?: Array<{
+      port: number
+      protocol: string
+      cidr?: string
+      source?: string
+    }>
+    egress?: Array<{
+      port: number
+      protocol: string
+      cidr?: string
+    }>
+  }>
+}

package/dist/cloudformation/builders/storage.d.ts

@@ -0,0 +1,8 @@
+import type { CloudFormationBuilder } from '../builder';
+/**
+ * Add S3 and EFS storage resources to CloudFormation template
+ */
+export declare function addStorageResources(builder: CloudFormationBuilder, config: StorageConfig): void;
+export declare interface StorageConfig {
+
+}

package/dist/cloudformation/index.d.ts

@@ -0,0 +1,24 @@
+export type {
+  CloudFormationTemplate,
+  CloudFormationResource,
+  CloudFormationParameter,
+  CloudFormationOutput,
+  CloudFormationCondition,
+  CloudFormationIntrinsicFunction,
+} from './types';
+export type { QueueConfig } from './builders/queue';
+export {
+  CloudFormationBuilder,
+  buildCloudFormationTemplate,
+} from './builder';
+export {
+  Fn,
+  Arn,
+  AWS_PSEUDO_PARAMETERS,
+} from './types';
+export { addNetworkResources } from './builders/network';
+export { addStorageResources } from './builders/storage';
+export { addComputeResources } from './builders/compute';
+export { addDatabaseResources } from './builders/database';
+export { addFunctionResources } from './builders/functions';
+export { addQueueResources } from './builders/queue';