@alienplatform/core 1.14.1 → 2.0.0

package/src/input.ts

@@ -1,380 +0,0 @@
-import type {
-  Platform,
-  StackInputDefaultValue,
-  StackInputDefinition,
-  StackInputEnvironmentMapping,
-  StackInputEnvironmentVariableType,
-  StackInputKind,
-  StackInputProvider,
-  StackInputValidation,
-} from "./generated/index.js"
-
-const stackInputDraftSymbol = Symbol("alien.stackInputDraft")
-const stackInputDefinitionsSymbol = Symbol("alien.stackInputDefinitions")
-
-export type StackInputValue = string | number | boolean | string[]
-
-type OneOrMany<T> = T | readonly T[]
-
-export type StackInputEnvMapping =
-  | string
-  | {
-      name: string
-      targetResources?: readonly string[]
-      type?: StackInputEnvironmentVariableType
-    }
-
-interface CommonInputOptions<TDefault extends StackInputValue> {
-  providedBy: OneOrMany<StackInputProvider>
-  required: boolean
-  label: string
-  description: string
-  placeholder?: string
-  default?: TDefault
-  platforms?: readonly Platform[]
-  env?: OneOrMany<StackInputEnvMapping>
-}
-
-export interface StringInputOptions extends CommonInputOptions<string> {
-  minLength?: number
-  maxLength?: number
-  pattern?: string
-  format?: string
-}
-
-export interface SecretInputOptions extends Omit<CommonInputOptions<string>, "default"> {
-  minLength?: number
-  maxLength?: number
-  pattern?: string
-  format?: string
-}
-
-export interface NumberInputOptions extends CommonInputOptions<number> {
-  min?: number
-  max?: number
-}
-
-export interface IntegerInputOptions extends CommonInputOptions<number> {
-  min?: number
-  max?: number
-}
-
-export interface BooleanInputOptions extends CommonInputOptions<boolean> {}
-
-export interface EnumInputOptions extends CommonInputOptions<string> {
-  placeholder?: string
-}
-
-export interface StringListInputOptions extends CommonInputOptions<string[]> {
-  minItems?: number
-  maxItems?: number
-}
-
-export interface StackInputRef<TValue extends StackInputValue = StackInputValue> {
-  readonly id: string
-  readonly kind: StackInputKind
-  readonly __value?: TValue
-}
-
-export type StackInputCollection = {
-  readonly [stackInputDefinitionsSymbol]: readonly StackInputDefinition[]
-}
-
-interface StackInputDraft<TValue extends StackInputValue = StackInputValue> {
-  readonly [stackInputDraftSymbol]: true
-  readonly kind: StackInputKind
-  readonly options: CommonInputOptions<TValue>
-  readonly validation: StackInputValidation
-}
-
-export type StackInputSet<T extends Record<string, StackInputDraft>> = {
-  readonly [K in keyof T]: T[K] extends StackInputDraft<infer TValue>
-    ? StackInputRef<TValue>
-    : never
-} & StackInputCollection
-
-export function inputs<const T extends Record<string, StackInputDraft>>(
-  drafts: T,
-): StackInputSet<T> {
-  const result = {} as Record<string, StackInputRef>
-  const definitions: StackInputDefinition[] = []
-
-  for (const [id, draft] of Object.entries(drafts)) {
-    validateInputId(id)
-    validateDraft(id, draft)
-
-    result[id] = { id, kind: draft.kind }
-    definitions.push({
-      id,
-      kind: draft.kind,
-      providedBy: normalizeArray(draft.options.providedBy),
-      required: draft.options.required,
-      label: draft.options.label,
-      description: draft.options.description,
-      placeholder: draft.options.placeholder,
-      default: toDefaultValue(draft.kind, draft.options.default),
-      platforms: draft.options.platforms ? [...draft.options.platforms] : undefined,
-      validation: Object.keys(draft.validation).length > 0 ? draft.validation : undefined,
-      env: normalizeEnv(draft.options.env),
-    })
-  }
-
-  Object.defineProperty(result, stackInputDefinitionsSymbol, {
-    value: Object.freeze(definitions),
-    enumerable: false,
-  })
-
-  return result as StackInputSet<T>
-}
-
-export function getStackInputDefinitions(
-  value: StackInputCollection | readonly StackInputDefinition[],
-): StackInputDefinition[] {
-  if (Array.isArray(value)) {
-    return [...(value as readonly StackInputDefinition[])]
-  }
-
-  return [...(value as StackInputCollection)[stackInputDefinitionsSymbol]]
-}
-
-function defineInput<TValue extends StackInputValue>(
-  kind: StackInputKind,
-  options: CommonInputOptions<TValue>,
-  validation: StackInputValidation = {},
-): StackInputDraft<TValue> {
-  return {
-    [stackInputDraftSymbol]: true,
-    kind,
-    options,
-    validation,
-  }
-}
-
-function defineStringInput(options: StringInputOptions): StackInputDraft<string> {
-  return defineInput("string", options, {
-    minLength: options.minLength,
-    maxLength: options.maxLength,
-    pattern: options.pattern,
-    format: options.format,
-  })
-}
-
-function defineSecretInput(options: SecretInputOptions): StackInputDraft<string> {
-  return defineInput("secret", options, {
-    minLength: options.minLength,
-    maxLength: options.maxLength,
-    pattern: options.pattern,
-    format: options.format,
-  })
-}
-
-function defineNumberInput(options: NumberInputOptions): StackInputDraft<number> {
-  return defineInput("number", options, {
-    min: numberToString(options.min),
-    max: numberToString(options.max),
-  })
-}
-
-function defineIntegerInput(options: IntegerInputOptions): StackInputDraft<number> {
-  return defineInput("integer", options, {
-    min: integerToString(options.min, "min"),
-    max: integerToString(options.max, "max"),
-  })
-}
-
-function defineBooleanInput(options: BooleanInputOptions): StackInputDraft<boolean> {
-  return defineInput("boolean", options)
-}
-
-function defineEnumInput<const TValues extends readonly [string, ...string[]]>(
-  values: TValues,
-  options: EnumInputOptions,
-): StackInputDraft<TValues[number]> {
-  return defineInput("enum", options, {
-    values: [...values],
-  }) as StackInputDraft<TValues[number]>
-}
-
-function defineStringListInput(options: StringListInputOptions): StackInputDraft<string[]> {
-  return defineInput("stringList", options, {
-    minItems: options.minItems,
-    maxItems: options.maxItems,
-  })
-}
-
-function normalizeArray<T>(value: OneOrMany<T>): T[] {
-  return Array.isArray(value) ? [...(value as readonly T[])] : [value as T]
-}
-
-function normalizeEnv(
-  value: OneOrMany<StackInputEnvMapping> | undefined,
-): StackInputEnvironmentMapping[] {
-  if (!value) {
-    return []
-  }
-
-  return normalizeArray(value).map(mapping => {
-    if (typeof mapping === "string") {
-      return { name: mapping }
-    }
-
-    return {
-      name: mapping.name,
-      targetResources: mapping.targetResources ? [...mapping.targetResources] : undefined,
-      type: mapping.type,
-    }
-  })
-}
-
-function toDefaultValue(
-  kind: StackInputKind,
-  value: StackInputValue | undefined,
-): StackInputDefaultValue | undefined {
-  if (value === undefined) {
-    return undefined
-  }
-
-  switch (kind) {
-    case "string":
-    case "enum":
-      return { type: "string", value: String(value) }
-    case "number":
-      return { type: "number", value: numberToString(value as number) ?? "" }
-    case "integer":
-      return { type: "number", value: integerToString(value as number, "default") ?? "" }
-    case "boolean":
-      return { type: "boolean", value: Boolean(value) }
-    case "stringList":
-      return { type: "stringList", value: [...(value as string[])] }
-    case "secret":
-      throw new Error("Secret stack inputs cannot declare a default value")
-  }
-}
-
-function validateDraft(id: string, draft: StackInputDraft): void {
-  if (!draft || draft[stackInputDraftSymbol] !== true) {
-    throw new Error(
-      `Stack input '${id}' must be created with alien.string(), alien.secret(), or another input helper`,
-    )
-  }
-
-  if (normalizeArray(draft.options.providedBy).length === 0) {
-    throw new Error(`Stack input '${id}' must include at least one providedBy value`)
-  }
-
-  if (!draft.options.label.trim()) {
-    throw new Error(`Stack input '${id}' must include a label`)
-  }
-
-  if (draft.options.required && !draft.options.description.trim()) {
-    throw new Error(`Stack input '${id}' must include a description when required is true`)
-  }
-
-  validateValidation(id, draft.kind, draft.validation)
-
-  for (const mapping of normalizeEnv(draft.options.env)) {
-    validateEnvName(id, mapping.name)
-    if (mapping.targetResources?.length === 0) {
-      throw new Error(
-        `Stack input '${id}' env mapping '${mapping.name}' cannot use an empty targetResources list`,
-      )
-    }
-  }
-}
-
-function validateInputId(id: string): void {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(id)) {
-    throw new Error(
-      `Stack input '${id}' id must start with a letter or underscore and contain only letters, digits, and underscores`,
-    )
-  }
-
-  if (!/[a-z]/.test(id)) {
-    throw new Error(`Stack input '${id}' id must not be all-caps env-var style`)
-  }
-}
-
-function validateEnvName(id: string, name: string): void {
-  if (!/^[A-Z_][A-Z0-9_]*$/.test(name)) {
-    throw new Error(
-      `Stack input '${id}' env name '${name}' must use uppercase letters, digits, and underscores`,
-    )
-  }
-}
-
-function validateValidation(
-  id: string,
-  kind: StackInputKind,
-  validation: StackInputValidation,
-): void {
-  const minLength = validation.minLength ?? undefined
-  const maxLength = validation.maxLength ?? undefined
-  const minItems = validation.minItems ?? undefined
-  const maxItems = validation.maxItems ?? undefined
-
-  if (minLength !== undefined && maxLength !== undefined && minLength > maxLength) {
-    throw new Error(`Stack input '${id}' minLength must be less than or equal to maxLength`)
-  }
-
-  if (minItems !== undefined && maxItems !== undefined && minItems > maxItems) {
-    throw new Error(`Stack input '${id}' minItems must be less than or equal to maxItems`)
-  }
-
-  if (kind === "enum" && (!validation.values || validation.values.length === 0)) {
-    throw new Error(`Stack input '${id}' enum values must not be empty`)
-  }
-
-  if (validation.pattern) {
-    validatePortablePattern(id, validation.pattern)
-  }
-}
-
-function validatePortablePattern(id: string, pattern: string): void {
-  if (pattern.length === 0) {
-    throw new Error(`Stack input '${id}' pattern must not be empty`)
-  }
-
-  if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 1) {
-    throw new Error(`Stack input '${id}' pattern must not use regex delimiters`)
-  }
-
-  if (/\\[1-9pPk]/.test(pattern) || /\(\?/.test(pattern) || /\[[^\]]*\[/.test(pattern)) {
-    throw new Error(
-      `Stack input '${id}' pattern is not portable across TypeScript, CloudFormation, and Terraform`,
-    )
-  }
-}
-
-function numberToString(value: number | undefined): string | undefined {
-  if (value === undefined) {
-    return undefined
-  }
-
-  if (!Number.isFinite(value)) {
-    throw new Error("Stack input number constraints must be finite")
-  }
-
-  return String(value)
-}
-
-function integerToString(value: number | undefined, field: string): string | undefined {
-  if (value === undefined) {
-    return undefined
-  }
-
-  if (!Number.isInteger(value)) {
-    throw new Error(`Stack input integer ${field} must be an integer`)
-  }
-
-  return String(value)
-}
-
-export {
-  defineBooleanInput as boolean,
-  defineEnumInput as enum,
-  defineIntegerInput as integer,
-  defineNumberInput as number,
-  defineSecretInput as secret,
-  defineStringInput as string,
-  defineStringListInput as stringList,
-}

package/src/kv.ts

@@ -1,72 +0,0 @@
-import { type Kv as KvConfig, KvSchema, type ResourceType } from "./generated/index.js"
-import { Resource } from "./resource.js"
-
-export type { KvOutputs, Kv as KvConfig } from "./generated/index.js"
-export { KvSchema as KvConfigSchema } from "./generated/index.js"
-
-/**
- * Represents a key-value store for data storage.
- * This resource provides a platform-agnostic interface over cloud-native KV services:
- * - AWS: DynamoDB with hash bucketing for load distribution
- * - GCP: Firestore with document-based storage and collection management
- * - Azure: Table Storage with client-side TTL filtering and partition fan-out
- *
- * The KV store supports basic operations: get, put, delete, exists, and scan_prefix.
- * All operations support TTL for automatic expiration and conditional operations.
- *
- * Key Features:
- * - Universal size limits: 512B keys, 64KB values
- * - TTL support with logical expiry across all platforms
- * - Conditional puts with if_not_exists support
- * - Prefix-based scanning with pagination
- * - Platform-specific optimizations while maintaining consistent API
- *
- * Size Constraints:
- * - Keys: ≤ 512 bytes with portable ASCII charset (a-z, A-Z, 0-9, -, _, :, /, .)
- * - Values: ≤ 65,536 bytes (64 KiB)
- *
- * TTL Behavior:
- * - Expired items appear absent on reads even if physically present
- * - TTL precision varies by platform but logical behavior is consistent
- *
- * Scan Operations:
- * - Returns arbitrary, unordered subsets in backend-natural order
- * - No ordering guarantees across platforms
- * - May return ≤ limit items (not guaranteed to fill)
- * - Clients must de-duplicate keys across pages
- * - No completeness guarantee under concurrent writes
- */
-export class Kv {
-  private _config: Partial<KvConfig> = {}
-
-  /**
-   * Creates a new KV builder.
-   * @param id Identifier for the KV store. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
-   */
-  constructor(id: string) {
-    this._config.id = id
-  }
-
-  /**
-   * Returns a ResourceType representing any KV resource.
-   * Used for creating permission targets that apply to all KV resources.
-   * @returns The "kv" resource type.
-   */
-  public static any(): ResourceType {
-    return "kv"
-  }
-
-  /**
-   * Builds and validates the KV configuration.
-   * @returns An immutable Resource representing the configured KV store.
-   * @throws Error if the KV configuration is invalid.
-   */
-  public build(): Resource {
-    const config = KvSchema.parse(this._config)
-
-    return new Resource({
-      type: "kv",
-      ...config,
-    })
-  }
-}

package/src/postgres.ts

@@ -1,107 +0,0 @@
-import {
-  type Postgres as PostgresConfig,
-  PostgresSchema,
-  type ResourceType,
-} from "./generated/index.js"
-import { Resource } from "./resource.js"
-
-export type { Postgres as PostgresConfig, PostgresOutputs } from "./generated/index.js"
-export { PostgresSchema as PostgresConfigSchema } from "./generated/index.js"
-
-/**
- * Represents a managed PostgreSQL database. The target platform decides the backend;
- * the database is private and reachable only by same-stack workloads.
- */
-export class Postgres {
-  private _config: Partial<PostgresConfig> = {
-    version: "17",
-    storage: "20Gi",
-    highAvailability: false,
-  }
-
-  /**
-   * Creates a new Postgres builder.
-   * @param id ID of the database. A database of this name is created on the server.
-   */
-  constructor(id: string) {
-    this._config.id = id
-  }
-
-  /**
-   * Returns a ResourceType representing any postgres resource.
-   * Used for creating permission targets that apply to all postgres resources.
-   * @returns The "postgres" resource type.
-   */
-  public static any(): ResourceType {
-    return "postgres"
-  }
-
-  /**
-   * Sets the major engine version ("15" | "16" | "17"). Default `"17"`.
-   * The union narrows the generated schema's free-form string for authoring ergonomics;
-   * keep it in sync with the supported majors if the Rust `Postgres` resource adds one.
-   * @param value The major version.
-   * @returns The Postgres builder instance.
-   */
-  public version(value: "15" | "16" | "17"): this {
-    this._config.version = value
-    return this
-  }
-
-  /**
-   * Requests vCPUs (e.g. "0.5", "2"). On GCP and Azure, `cpu` and `memory` together pick the
-   * smallest tier that satisfies both. On AWS (Aurora Serverless v2) sizing comes from `memory`, so
-   * `cpu` is ignored.
-   * @param value The requested vCPUs.
-   * @returns The Postgres builder instance.
-   */
-  public cpu(value: string): this {
-    this._config.cpu = value
-    return this
-  }
-
-  /**
-   * Requests memory (e.g. "1Gi", "8Gi"). Drives the size on AWS (the ACU ceiling) and, together
-   * with `cpu`, the tier on GCP and Azure.
-   * @param value The requested memory.
-   * @returns The Postgres builder instance.
-   */
-  public memory(value: string): this {
-    this._config.memory = value
-    return this
-  }
-
-  /**
-   * Sets allocated storage (e.g. "100Gi"). Default `"20Gi"`. Grow-only.
-   * @param value The storage size.
-   * @returns The Postgres builder instance.
-   */
-  public storage(value: string): this {
-    this._config.storage = value
-    return this
-  }
-
-  /**
-   * Enables multi-AZ / regional / zone-redundant high availability. Default `false`.
-   * @param value Whether to enable HA.
-   * @returns The Postgres builder instance.
-   */
-  public highAvailability(value = true): this {
-    this._config.highAvailability = value
-    return this
-  }
-
-  /**
-   * Builds and validates the postgres configuration.
-   * @returns An immutable Resource representing the configured database.
-   * @throws Error if the configuration is invalid.
-   */
-  public build(): Resource {
-    const config = PostgresSchema.parse(this._config)
-
-    return new Resource({
-      type: "postgres",
-      ...config,
-    })
-  }
-}

package/src/queue.ts

@@ -1,44 +0,0 @@
-import { type Queue as QueueConfig, QueueSchema, type ResourceType } from "./generated/index.js"
-import { Resource } from "./resource.js"
-
-export type { QueueOutputs, Queue as QueueConfig } from "./generated/index.js"
-export { QueueSchema as QueueConfigSchema } from "./generated/index.js"
-
-/**
- * Represents a message queue resource with minimal, portable semantics.
- * Queue integrates with platform-native services (AWS SQS, GCP Pub/Sub, Azure Service Bus).
- */
-export class Queue {
-  private _config: Partial<QueueConfig> = {}
-
-  /**
-   * Creates a new Queue builder.
-   * @param id Identifier for the queue. Must contain only alphanumeric characters, hyphens, and underscores ([A-Za-z0-9-_]). Maximum 64 characters.
-   */
-  constructor(id: string) {
-    this._config.id = id
-  }
-
-  /**
-   * Returns a ResourceType representing any queue resource.
-   * Used for creating permission targets that apply to all queue resources.
-   * @returns The "queue" resource type.
-   */
-  public static any(): ResourceType {
-    return "queue"
-  }
-
-  /**
-   * Builds and validates the queue configuration.
-   * @returns An immutable Resource representing the configured queue.
-   * @throws Error if the queue configuration is invalid.
-   */
-  public build(): Resource {
-    const config = QueueSchema.parse(this._config)
-
-    return new Resource({
-      type: "queue",
-      ...config,
-    })
-  }
-}

package/src/resource.ts

@@ -1,25 +0,0 @@
-import type { BaseResource, ResourceRef } from "./generated/index.js"
-
-export { ResourceTypeSchema } from "./generated/index.js"
-export type { ResourceType } from "./generated/index.js"
-
-/**
- * Represents a generic cloud resource within the Alien framework.
- * This class encapsulates the common properties of a resource, such as its name and configuration.
- */
-export class Resource {
-  /**
-   * Creates a new Resource instance.
-   * @param config The configuration object for this specific resource type.
-   */
-  constructor(public config: BaseResource) {}
-
-  /**
-   * Returns a reference to this resource.
-   * A resource reference is used to link resources together (e.g., granting a Worker access to a Storage bucket).
-   * @returns A ResourceRef object containing the type and name of this resource.
-   */
-  public ref(): ResourceRef {
-    return { type: this.config.type, id: this.config.id }
-  }
-}