@stacksjs/ts-cloud 0.7.56 → 0.7.58

package/dist/{chunk-arsh1g5h.js → chunk-zqtpg06c.js}

@@ -1173,15 +1173,21 @@ class XMLParser {
 
 // src/aws/client.ts
 function resolveS3Endpoint(options) {
-  const base = options.endpoint || `s3.${options.region}.amazonaws.com`;
+  const rawEndpoint = options.endpoint || `s3.${options.region}.amazonaws.com`;
+  const parsed = new URL(/^https?:\/\//i.test(rawEndpoint) ? rawEndpoint : `https://${rawEndpoint}`);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.pathname !== "/" && parsed.pathname !== "" || parsed.search || parsed.hash || parsed.username || parsed.password) {
+    throw new Error("S3 endpoint must be an HTTP(S) origin without a path");
+  }
+  const protocol = parsed.protocol.slice(0, -1);
+  const base = parsed.host;
   if (!options.bucket) {
-    return { host: base, path: options.path };
+    return { protocol, host: base, path: options.path };
   }
   if (options.forcePathStyle) {
     const path = options.path === "/" ? `/${options.bucket}` : `/${options.bucket}${options.path}`;
-    return { host: base, path };
+    return { protocol, host: base, path };
   }
-  return { host: `${options.bucket}.${base}`, path: options.path };
+  return { protocol, host: `${options.bucket}.${base}`, path: options.path };
 }
 
 class AWSClient {
@@ -1409,6 +1415,7 @@ class AWSClient {
     const { service, region, queryParams } = options;
     let { path } = options;
     let host;
+    let protocol = "https";
     if (service === "s3") {
       const resolved = resolveS3Endpoint({
         region,
@@ -1417,6 +1424,7 @@ class AWSClient {
         endpoint: this.config.endpoint,
         forcePathStyle: this.config.forcePathStyle
       });
+      protocol = resolved.protocol;
       host = resolved.host;
       path = resolved.path;
     } else if (service === "cloudfront") {
@@ -1434,7 +1442,7 @@ class AWSClient {
     } else {
       host = `${service}.${region}.amazonaws.com`;
     }
-    let url = `https://${host}${path}`;
+    let url = `${protocol}://${host}${path}`;
     if (queryParams && Object.keys(queryParams).length > 0) {
       const queryString = Object.keys(queryParams).map((k) => `${this.uriEncode(k)}=${this.uriEncode(queryParams[k])}`).join("&");
       url += `?${queryString}`;
@@ -1510,12 +1518,7 @@ class AWSClient {
     if (service === "email")
       signingService = "ses";
     const credentialScope = `${dateStamp}/${region}/${signingService}/aws4_request`;
-    const stringToSign = [
-      algorithm,
-      amzDate,
-      credentialScope,
-      this.sha256(canonicalRequest)
-    ].join(`
+    const stringToSign = [algorithm, amzDate, credentialScope, this.sha256(canonicalRequest)].join(`
 `);
     const signingKey = this.getSignatureKey(credentials.secretAccessKey, dateStamp, region, signingService);
     const signature = this.hmac(signingKey, stringToSign);

package/dist/compose/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './parser';
+export * from './templates';
+export * from './runtime';
+export * from './store';
+export * from './service';

package/dist/compose/parser.d.ts

@@ -0,0 +1,13 @@
+import type { ComposeApplicationManifest, ComposeParseResult } from './types';
+export declare function parseCompose(source: string, input: {
+    name: string;
+    projectId: string;
+    environmentId: string;
+    slug?: string;
+}): ComposeParseResult;
+export declare function exportCompose(manifest: ComposeApplicationManifest): string;
+export declare function diffCompose(previous: ComposeApplicationManifest, next: ComposeApplicationManifest): Array<{
+    path: string;
+    before?: unknown;
+    after?: unknown;
+}>;

package/dist/compose/parser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compose/runtime.d.ts

@@ -0,0 +1,10 @@
+import type { ComposeApplicationManifest } from './types';
+export declare function composeProjectName(manifest: ComposeApplicationManifest): string;
+export declare function buildComposeRuntimeCommand(manifest: ComposeApplicationManifest, action: 'deploy' | 'redeploy' | 'start' | 'stop' | 'delete' | 'status', input?: {
+    removeVolumes?: boolean;
+    service?: string;
+    replicas?: number;
+}): string;
+export declare function buildComposeScaleCommand(manifest: ComposeApplicationManifest, service: string, replicas: number): string;
+export declare function buildComposeLogsCommand(manifest: ComposeApplicationManifest, service: string, lines?: number): string;
+export declare function buildComposeShellCommand(manifest: ComposeApplicationManifest, service: string, command?: string[]): string;

package/dist/compose/service.d.ts

@@ -0,0 +1,18 @@
+import type { ControlPlaneOperation, ControlPlaneStore } from '../control-plane';
+import type { ComposeApplicationRecord } from './types';
+import { DurableOperationQueue } from '../queue';
+import { ComposeApplicationStore } from './store';
+export type ComposeLifecycleAction = 'deploy' | 'redeploy' | 'start' | 'stop' | 'delete' | 'scale';
+export declare class ComposeApplicationService {
+    readonly controlPlane: ControlPlaneStore;
+    readonly applications: ComposeApplicationStore;
+    readonly queue: DurableOperationQueue;
+    constructor(controlPlane: ControlPlaneStore);
+    enqueue(application: ComposeApplicationRecord, action: ComposeLifecycleAction, input?: {
+        actorId?: string;
+        service?: string;
+        replicas?: number;
+        removeVolumes?: boolean;
+        confirmation?: string;
+    }): ControlPlaneOperation;
+}

package/dist/compose/store.d.ts

@@ -0,0 +1,59 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { ComposeApplicationRecord, ComposeParseResult, ComposeServiceState } from './types';
+export declare class ComposeApplicationStore {
+    readonly controlPlane: ControlPlaneStore;
+    private readonly now;
+    private readonly id;
+    constructor(controlPlane: ControlPlaneStore, options?: {
+        now?: () => Date;
+        id?: () => string;
+    });
+    private persist;
+    import(source: string, input: {
+        name: string;
+        slug?: string;
+        projectId: string;
+        environmentId: string;
+        createdByActorId?: string;
+    }): {
+        application: ComposeApplicationRecord;
+        parsed: ComposeParseResult;
+    };
+    fromTemplate(templateId: string, inputs: Record<string, string>, input: {
+        name: string;
+        slug?: string;
+        projectId: string;
+        environmentId: string;
+        version?: string;
+        createdByActorId?: string;
+    }): {
+        application: ComposeApplicationRecord;
+        parsed: ComposeParseResult;
+    };
+    preview(source: string, input: {
+        name: string;
+        slug?: string;
+        projectId: string;
+        environmentId: string;
+    }): ComposeParseResult;
+    get(id: string): ComposeApplicationRecord | undefined;
+    getByResource(resourceId: string): ComposeApplicationRecord | undefined;
+    getBySlug(projectId: string, environmentId: string, slug: string): ComposeApplicationRecord | undefined;
+    list(input?: {
+        projectId?: string;
+        environmentId?: string;
+        includeDeleted?: boolean;
+    }): ComposeApplicationRecord[];
+    services(applicationId: string): ComposeServiceState[];
+    transition(id: string, status: ComposeApplicationRecord['status'], input?: {
+        operationId?: string;
+        services?: Array<{
+            name: string;
+            status: ComposeServiceState['status'];
+            replicas?: number;
+            healthyReplicas?: number;
+            observedState?: JsonValue;
+        }>;
+        error?: string;
+    }): ComposeApplicationRecord;
+}

package/dist/compose/store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compose/templates.d.ts

@@ -0,0 +1,17 @@
+import type { ComposeApplicationManifest, ComposeCatalogResult, ComposeParseResult, ComposeTemplate, ComposeTemplateUpgradePlan } from './types';
+export declare function listComposeTemplates(): ComposeTemplate[];
+export declare function getComposeTemplate(id: string, version?: string): ComposeTemplate | undefined;
+export declare function renderComposeTemplate(id: string, inputs: Record<string, string>, target: {
+    name: string;
+    projectId: string;
+    environmentId: string;
+}, version?: string): ComposeParseResult;
+export declare function parseComposeCatalog(source: string, target: {
+    projectId: string;
+    environmentId: string;
+}): ComposeCatalogResult;
+export declare function planComposeTemplateUpgrade(current: ComposeApplicationManifest, previousTemplate: ComposeApplicationManifest, id: string, inputs: Record<string, string>, target: {
+    name: string;
+    projectId: string;
+    environmentId: string;
+}, version: string): ComposeTemplateUpgradePlan;

package/dist/compose/types.d.ts

@@ -0,0 +1,164 @@
+import type { JsonValue } from '../control-plane';
+export type ComposeDiagnosticSeverity = 'warning' | 'error';
+export interface ComposeDiagnostic {
+    severity: ComposeDiagnosticSeverity;
+    path: string;
+    code: string;
+    message: string;
+    alternative?: string;
+}
+export interface ComposePort {
+    target: number;
+    published?: number;
+    protocol: 'tcp' | 'udp';
+}
+export interface ComposeVolumeMount {
+    source: string;
+    target: string;
+    readOnly: boolean;
+}
+export interface ComposeDependency {
+    service: string;
+    condition: 'service_started' | 'service_healthy' | 'service_completed_successfully';
+}
+export interface ComposeHealthCheck {
+    test: string[];
+    intervalSeconds: number;
+    timeoutSeconds: number;
+    retries: number;
+    startPeriodSeconds?: number;
+}
+export interface ComposeBuild {
+    context: string;
+    dockerfile: string;
+    target?: string;
+    args: Record<string, string | {
+        secretRef: string;
+    }>;
+}
+export interface ComposeService {
+    name: string;
+    image?: string;
+    build?: ComposeBuild;
+    command?: string[];
+    entrypoint?: string[];
+    environment: Record<string, string | {
+        secretRef: string;
+    }>;
+    ports: ComposePort[];
+    volumes: ComposeVolumeMount[];
+    networks: string[];
+    dependsOn: ComposeDependency[];
+    healthCheck?: ComposeHealthCheck;
+    restart: 'no' | 'always' | 'on-failure' | 'unless-stopped';
+    cpu?: number;
+    memoryMb?: number;
+    replicas: number;
+    domains: string[];
+}
+export interface ComposeApplicationManifest {
+    apiVersion: 'ts-cloud.dev/v1';
+    kind: 'ComposeApplication';
+    metadata: {
+        name: string;
+        slug: string;
+        projectId: string;
+        environmentId: string;
+    };
+    spec: {
+        services: Record<string, ComposeService>;
+        networks: string[];
+        volumes: string[];
+        dependencyOrder: string[];
+    };
+}
+export interface ComposeParseResult {
+    valid: boolean;
+    manifest: ComposeApplicationManifest;
+    diagnostics: ComposeDiagnostic[];
+    redactedSource: string;
+    sourceHash: string;
+}
+export interface ComposeApplicationRecord {
+    id: string;
+    resourceId: string;
+    projectId: string;
+    environmentId: string;
+    name: string;
+    slug: string;
+    status: 'draft' | 'ready' | 'deploying' | 'running' | 'stopped' | 'degraded' | 'failed' | 'deleting' | 'deleted';
+    sourceKind: 'compose' | 'template';
+    sourceHash: string;
+    redactedSource: string;
+    manifest: ComposeApplicationManifest;
+    diagnostics: ComposeDiagnostic[];
+    templateId?: string;
+    templateVersion?: string;
+    latestOperationId?: string;
+    createdByActorId?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt?: string;
+}
+export interface ComposeServiceState {
+    applicationId: string;
+    serviceName: string;
+    status: 'pending' | 'starting' | 'running' | 'stopped' | 'unhealthy' | 'failed' | 'unknown';
+    replicas: number;
+    healthyReplicas: number;
+    latestOperationId?: string;
+    observedState: JsonValue;
+    updatedAt: string;
+}
+export interface ComposeTemplateInput {
+    name: string;
+    label: string;
+    required: boolean;
+    secret: boolean;
+    default?: string;
+    description?: string;
+}
+export interface ComposeTemplate {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    version: string;
+    source: string;
+    sourceVersion: string;
+    architecture: string;
+    minimumResources: {
+        cpu: number;
+        memoryMb: number;
+    };
+    exposedServices: string[];
+    maintenanceNotes: string;
+    lastVerifiedAt: string;
+    inputs: ComposeTemplateInput[];
+    checksum: string;
+    builtin: boolean;
+}
+export interface ComposeCatalogResult {
+    valid: boolean;
+    source: string;
+    templates: Array<{
+        template: ComposeTemplate;
+        parsed: ComposeParseResult;
+    }>;
+    diagnostics: ComposeDiagnostic[];
+}
+export interface ComposeTemplateUpgradePlan {
+    template: ComposeTemplate;
+    parsed: ComposeParseResult;
+    templateChanges: Array<{
+        path: string;
+        before?: unknown;
+        after?: unknown;
+    }>;
+    userChanges: Array<{
+        path: string;
+        before?: unknown;
+        after?: unknown;
+    }>;
+}

package/dist/configuration/backends.d.ts

@@ -0,0 +1,66 @@
+import type { SecretsManagerClient } from '../aws/secrets-manager';
+import type { SSMClient } from '../aws/ssm';
+import type { ControlPlaneStore } from '../control-plane';
+import type { ConfigurationBackend } from './model';
+export interface SecretWrite {
+    reference?: string;
+    name: string;
+    value: string;
+    idempotencyKey: string;
+}
+export interface SecretWriteResult {
+    reference: string;
+    version: string;
+}
+export interface ConfigurationSecretBackend {
+    readonly kind: Exclude<ConfigurationBackend, 'plaintext'>;
+    put(input: SecretWrite): Promise<SecretWriteResult>;
+    resolve(reference: string): Promise<string>;
+    remove(reference: string): Promise<void>;
+    validate(reference: string): Promise<boolean>;
+}
+export declare class LocalEncryptedConfigurationBackend implements ConfigurationSecretBackend {
+    private readonly controlPlane;
+    private readonly now;
+    readonly kind: 'local_encrypted';
+    private readonly key;
+    constructor(controlPlane: ControlPlaneStore, encryptionKey: string, now?: () => Date);
+    private encrypt;
+    private decrypt;
+    put(input: SecretWrite): Promise<SecretWriteResult>;
+    resolve(reference: string): Promise<string>;
+    remove(reference: string): Promise<void>;
+    validate(reference: string): Promise<boolean>;
+}
+type SecretsManagerApi = Pick<SecretsManagerClient, 'createSecret' | 'putSecretValue' | 'getSecretValue' | 'describeSecret' | 'deleteSecret'>;
+export declare class AwsSecretsManagerConfigurationBackend implements ConfigurationSecretBackend {
+    private readonly client;
+    private readonly region;
+    readonly kind: 'aws_secrets_manager';
+    constructor(client: SecretsManagerApi, region: string);
+    put(input: SecretWrite): Promise<SecretWriteResult>;
+    resolve(reference: string): Promise<string>;
+    remove(reference: string): Promise<void>;
+    validate(reference: string): Promise<boolean>;
+    private id;
+}
+type SsmApi = Pick<SSMClient, 'putParameter' | 'getParameter' | 'deleteParameter'>;
+export declare class AwsSsmConfigurationBackend implements ConfigurationSecretBackend {
+    private readonly client;
+    private readonly region;
+    readonly kind: 'aws_ssm';
+    constructor(client: SsmApi, region: string);
+    put(input: SecretWrite): Promise<SecretWriteResult>;
+    resolve(reference: string): Promise<string>;
+    remove(reference: string): Promise<void>;
+    validate(reference: string): Promise<boolean>;
+    private name;
+}
+export declare class ExternalConfigurationBackend implements ConfigurationSecretBackend {
+    readonly kind: 'external';
+    put(): Promise<SecretWriteResult>;
+    resolve(): Promise<string>;
+    remove(): Promise<void>;
+    validate(reference: string): Promise<boolean>;
+}
+export {};

package/dist/configuration/backends.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/configuration/dotenv.d.ts

@@ -0,0 +1,14 @@
+export interface DotenvDiagnostic {
+    line: number;
+    key?: string;
+    severity: 'warning' | 'error';
+    code: 'invalid_line' | 'invalid_key' | 'duplicate' | 'conflict' | 'unterminated_quote';
+    message: string;
+}
+export interface DotenvDocument {
+    values: Record<string, string>;
+    diagnostics: DotenvDiagnostic[];
+    valid: boolean;
+}
+export declare function parseDotenv(source: string): DotenvDocument;
+export declare function serializeDotenv(values: Record<string, string>): string;

package/dist/configuration/dotenv.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/configuration/index.d.ts

@@ -0,0 +1,6 @@
+export * from './model';
+export * from './store';
+export * from './dotenv';
+export * from './backends';
+export * from './service';
+export * from './migrate';

package/dist/configuration/migrate.d.ts

@@ -0,0 +1,10 @@
+import type { CloudConfig } from '@ts-cloud/core';
+import type { DashboardControlPlane } from '../deploy/dashboard-control-plane';
+import { ConfigurationService } from './service';
+export interface ConfigurationSyncResult {
+    added: number;
+    changed: number;
+    removed: number;
+    overridden: number;
+}
+export declare function synchronizeConfiguredConfiguration(service: ConfigurationService, controlPlane: DashboardControlPlane, config: CloudConfig, actorId?: string): Promise<ConfigurationSyncResult>;

package/dist/configuration/migrate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/configuration/model.d.ts

@@ -0,0 +1,50 @@
+import type { JsonValue } from '../control-plane';
+export type ConfigurationScopeType = 'project' | 'environment' | 'service' | 'function' | 'preview';
+export type ConfigurationKind = 'variable' | 'secret';
+export type ConfigurationBackend = 'plaintext' | 'local_encrypted' | 'aws_secrets_manager' | 'aws_ssm' | 'external';
+export interface ConfigurationScope {
+    type: ConfigurationScopeType;
+    id: string;
+    environmentId?: string;
+    resourceId?: string;
+    previewId?: string;
+}
+export interface ConfigurationEntry {
+    id: string;
+    organizationId: string;
+    projectId: string;
+    scope: ConfigurationScope;
+    key: string;
+    kind: ConfigurationKind;
+    value?: string;
+    valueFingerprint: string;
+    secretRef?: string;
+    backend: ConfigurationBackend;
+    backendVersion?: string;
+    origin: 'managed' | 'config' | 'migrated';
+    required: boolean;
+    metadata: Record<string, JsonValue>;
+    lastUsedAt?: string;
+    rotatedAt?: string;
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConfigurationDependency {
+    entryId: string;
+    resourceId: string;
+    injectionTarget: 'environment' | 'native_reference' | 'file';
+    required: boolean;
+    requiresRedeploy: boolean;
+    lastDeployedVersion?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ConfigurationMutationResult {
+    added: string[];
+    changed: string[];
+    removed: string[];
+    unchanged: string[];
+    affectedResourceIds: string[];
+    versions: Record<string, number>;
+}

package/dist/configuration/service.d.ts

@@ -0,0 +1,144 @@
+import type { JsonValue } from '../control-plane';
+import type { ConfigurationSecretBackend } from './backends';
+import type { ConfigurationBackend, ConfigurationEntry, ConfigurationKind, ConfigurationMutationResult, ConfigurationScope } from './model';
+import { parseDotenv } from './dotenv';
+import { ConfigurationStore } from './store';
+export interface ConfigurationMetadata {
+    id: string;
+    key: string;
+    kind: ConfigurationKind;
+    scope: ConfigurationScope;
+    inherited: boolean;
+    overridden: boolean;
+    required: boolean;
+    backend?: ConfigurationBackend;
+    backendVersion?: string;
+    reference?: string;
+    lastUsedAt?: string;
+    rotatedAt?: string;
+    version: number;
+    updatedAt: string;
+    value?: string;
+}
+export interface ConfigurationWarning {
+    key?: string;
+    code: 'reserved' | 'limit' | 'missing_required' | 'stale_reference';
+    message: string;
+}
+export interface ResolvedConfiguration {
+    values: Record<string, string>;
+    entries: Record<string, ConfigurationMetadata>;
+    warnings: ConfigurationWarning[];
+    configurationHash: string;
+}
+export interface SetConfigurationInput {
+    organizationId: string;
+    projectId: string;
+    scope: ConfigurationScope;
+    key: string;
+    kind: ConfigurationKind;
+    value?: string;
+    reference?: string;
+    backend?: Exclude<ConfigurationBackend, 'plaintext'>;
+    required?: boolean;
+    metadata?: Record<string, JsonValue>;
+    expectedVersion?: number;
+    confirmed?: boolean;
+    idempotencyKey?: string;
+    actorId?: string;
+    origin?: ConfigurationEntry['origin'];
+}
+export interface ConfigurationPlan {
+    added: string[];
+    changed: string[];
+    removed: string[];
+    unchanged: string[];
+    affectedResourceIds: string[];
+    warnings: ConfigurationWarning[];
+}
+export declare class ConfigurationService {
+    readonly store: ConfigurationStore;
+    private readonly backends;
+    private readonly fingerprintKey;
+    private readonly now;
+    constructor(store: ConfigurationStore, options: {
+        encryptionKey: string;
+        fingerprintKey?: string;
+        backends?: ConfigurationSecretBackend[];
+        now?: () => Date;
+    });
+    list(input: {
+        projectId: string;
+        scope?: ConfigurationScope;
+        kind?: ConfigurationKind;
+        search?: string;
+        canReadSecretMetadata?: boolean;
+    }): ConfigurationMetadata[];
+    plan(input: {
+        projectId: string;
+        scope: ConfigurationScope;
+        values: Record<string, string>;
+        removeMissing?: boolean;
+    }): ConfigurationPlan;
+    set(input: SetConfigurationInput): Promise<{
+        entry: ConfigurationEntry;
+        mutation: ConfigurationMutationResult;
+        warnings: ConfigurationWarning[];
+    }>;
+    importDotenv(input: Omit<SetConfigurationInput, 'key' | 'kind' | 'value'> & {
+        source: string;
+        secretKeys?: string[];
+    }): Promise<{
+        document: ReturnType<typeof parseDotenv>;
+        mutation?: ConfigurationMutationResult;
+        warnings: ConfigurationWarning[];
+    }>;
+    exportVariables(input: {
+        projectId: string;
+        scope: ConfigurationScope;
+    }): string;
+    transfer(input: {
+        entryId: string;
+        targetScope: ConfigurationScope;
+        mode: 'copy' | 'move';
+        confirmed?: boolean;
+        actorId?: string;
+        idempotencyKey?: string;
+    }): Promise<{
+        entry: ConfigurationEntry;
+        mutation: ConfigurationMutationResult;
+    }>;
+    resolve(input: {
+        projectId: string;
+        environmentId?: string;
+        resourceId?: string;
+        functionId?: string;
+        previewId?: string;
+        trustedPreview?: boolean;
+        allowedPreviewSecrets?: string[];
+        nativeReferences?: boolean;
+        canReadSecretMetadata?: boolean;
+    }): Promise<ResolvedConfiguration>;
+    reveal(input: {
+        entryId: string;
+        canRevealSecrets: boolean;
+        recentlyAuthenticated: boolean;
+        actorId?: string;
+    }): Promise<string>;
+    remove(input: {
+        entryId: string;
+        expectedVersion: number;
+        confirmed?: boolean;
+        actorId?: string;
+    }): Promise<ConfigurationMutationResult>;
+    private applies;
+    private rank;
+    private fingerprint;
+    private requestHash;
+    private backend;
+    private backendName;
+    private isProduction;
+    private warnings;
+    private affectedResources;
+    private audit;
+}

package/dist/configuration/service.test.d.ts

@@ -0,0 +1 @@
+export {};