@stacksjs/ts-cloud 0.7.56 → 0.7.58

package/dist/storage/service.d.ts

@@ -0,0 +1,95 @@
+import type { ControlPlaneOperation, JsonValue } from '../control-plane';
+import type { QueueOperationHandler } from '../queue';
+import type { PersistentVolume, VolumeAttachment, VolumeCapabilities, VolumeDriver, VolumeSnapshot, VolumeType } from './model';
+import { DurableOperationQueue } from '../queue';
+import { VolumeStore } from './store';
+declare const actions: readonly ['create', 'attach', 'detach', 'resize', 'snapshot', 'restore', 'delete', 'adopt', 'usage'];
+export declare function unsupportedVolumeCapabilities(reason: string): VolumeCapabilities;
+export declare function volumeCapabilities(supported: readonly (typeof actions)[number][], overrides?: Partial<VolumeCapabilities>): VolumeCapabilities;
+export declare function validateMountPath(path: string): void;
+export declare function validateAttachment(input: {
+    targetPath: string;
+    uid?: number;
+    gid?: number;
+    mode?: string;
+    propagation?: VolumeAttachment['propagation'];
+}): void;
+export interface VolumeMutationResult {
+    volume: PersistentVolume;
+    operation: ControlPlaneOperation;
+    attachment?: VolumeAttachment;
+    snapshot?: VolumeSnapshot;
+}
+export declare class VolumeService {
+    readonly store: VolumeStore;
+    readonly drivers: readonly VolumeDriver[];
+    private readonly now;
+    readonly queue: DurableOperationQueue;
+    constructor(store: VolumeStore, drivers: readonly VolumeDriver[], queue?: DurableOperationQueue, now?: () => Date);
+    private driver;
+    private capability;
+    private queueMutation;
+    create(input: {
+        organizationId: string;
+        projectId: string;
+        environmentId?: string;
+        resourceId?: string;
+        name: string;
+        provider: string;
+        type: VolumeType;
+        capacityBytes?: number;
+        filesystem?: string;
+        encrypted?: boolean;
+        desiredState?: Record<string, JsonValue>;
+        actorId?: string;
+    }): VolumeMutationResult;
+    attach(volumeId: string, input: {
+        resourceId: string;
+        targetPath: string;
+        readOnly?: boolean;
+        uid?: number;
+        gid?: number;
+        mode?: string;
+        propagation?: VolumeAttachment['propagation'];
+        driverOptions?: Record<string, JsonValue>;
+        actorId?: string;
+    }): VolumeMutationResult;
+    detach(volumeId: string, attachmentId: string, input?: {
+        force?: boolean;
+        drained?: boolean;
+        unmounted?: boolean;
+        confirmation?: string;
+        actorId?: string;
+    }): VolumeMutationResult;
+    resize(volumeId: string, capacityBytes: number, input?: {
+        drained?: boolean;
+        actorId?: string;
+    }): VolumeMutationResult;
+    snapshot(volumeId: string, input?: {
+        name?: string;
+        actorId?: string;
+    }): VolumeMutationResult;
+    restore(snapshotId: string, input: {
+        name: string;
+        actorId?: string;
+    }): VolumeMutationResult;
+    delete(volumeId: string, input: {
+        recentAuthAt?: string;
+        confirmation?: string;
+        backupOverride?: boolean;
+        backupOverrideConfirmation?: string;
+        actorId?: string;
+    }): VolumeMutationResult;
+    discover(input: {
+        organizationId: string;
+        projectId: string;
+        environmentId?: string;
+        actorId?: string;
+    }): Promise<PersistentVolume[]>;
+    adopt(volumeId: string, input: {
+        name: string;
+        actorId?: string;
+    }): PersistentVolume;
+}
+export declare function createVolumeQueueHandlers(store: VolumeStore, drivers: readonly VolumeDriver[]): Record<string, QueueOperationHandler>;
+export {};

package/dist/storage/storage.test.d.ts

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

package/dist/storage/store.d.ts

@@ -0,0 +1,40 @@
+import type { ControlPlaneStore, JsonValue } from '../control-plane';
+import type { PersistentVolume, VolumeAttachment, VolumeInventoryItem, VolumeSnapshot } from './model';
+export declare class VolumeStore {
+    readonly controlPlane: ControlPlaneStore;
+    private readonly now;
+    private readonly id;
+    constructor(controlPlane: ControlPlaneStore, now?: () => Date, id?: () => string);
+    get(id: string): PersistentVolume | undefined;
+    list(input: {
+        projectId: string;
+        environmentId?: string;
+        includeDeleted?: boolean;
+    }): PersistentVolume[];
+    create(input: Omit<PersistentVolume, 'id' | 'version' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): PersistentVolume;
+    update(id: string, expectedVersion: number, patch: Partial<Omit<PersistentVolume, 'id' | 'organizationId' | 'projectId' | 'createdAt' | 'version'>>): PersistentVolume;
+    attachments(volumeId: string): VolumeAttachment[];
+    attachment(id: string): VolumeAttachment | undefined;
+    upsertAttachment(input: Omit<VolumeAttachment, 'id' | 'version' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): VolumeAttachment;
+    updateAttachment(id: string, patch: Partial<Pick<VolumeAttachment, 'desiredState' | 'observedState' | 'operationId' | 'lastError'>>): VolumeAttachment;
+    snapshots(volumeId: string): VolumeSnapshot[];
+    snapshot(id: string): VolumeSnapshot | undefined;
+    createSnapshot(input: Omit<VolumeSnapshot, 'id' | 'createdAt' | 'updatedAt'> & {
+        id?: string;
+    }): VolumeSnapshot;
+    updateSnapshot(id: string, patch: Partial<VolumeSnapshot>): VolumeSnapshot;
+    inventory(projectId: string, environmentId?: string): VolumeInventoryItem[];
+    audit(input: {
+        organizationId: string;
+        projectId: string;
+        environmentId?: string;
+        actorId?: string;
+        type: string;
+        volumeId: string;
+        payload?: Record<string, JsonValue>;
+    }): void;
+}

package/dist/telemetry/correlation.test.d.ts

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

package/dist/telemetry/index.d.ts

@@ -0,0 +1,4 @@
+export * from './model';
+export * from './policy';
+export * from './redaction';
+export * from './store';

package/dist/telemetry/model.d.ts

@@ -0,0 +1,145 @@
+import type { JsonValue } from '../control-plane';
+export type TelemetryKind = 'metric' | 'log' | 'trace' | 'request' | 'event';
+export type TelemetryAggregation = 'sum' | 'avg' | 'min' | 'max' | 'count' | 'p50' | 'p90' | 'p95' | 'p99';
+export type TelemetryFreshness = 'live' | 'stale' | 'unavailable';
+export interface TelemetryCorrelation {
+    traceId?: string;
+    requestId?: string;
+    deploymentId?: string;
+    releaseId?: string;
+    workloadId?: string;
+}
+export interface TelemetryRecord extends TelemetryCorrelation {
+    id: string;
+    projectId: string;
+    environmentId?: string;
+    resourceId?: string;
+    kind: TelemetryKind;
+    source: string;
+    name: string;
+    timestamp: string;
+    observedAt: string;
+    value?: number;
+    unit?: string;
+    level?: string;
+    message?: string;
+    durationMs?: number;
+    statusCode?: number;
+    method?: string;
+    host?: string;
+    pathTemplate?: string;
+    bytesIn?: number;
+    bytesOut?: number;
+    region?: string;
+    cacheResult?: string;
+    upstream?: string;
+    sampled: boolean;
+    attributes: Record<string, JsonValue>;
+    ingestedBytes: number;
+}
+export interface AppendTelemetryInput extends Omit<TelemetryRecord, 'id' | 'observedAt' | 'sampled' | 'attributes' | 'ingestedBytes'> {
+    id?: string;
+    observedAt?: string;
+    sampled?: boolean;
+    attributes?: Record<string, unknown>;
+}
+export interface TelemetryQuery {
+    projectId: string;
+    environmentId?: string;
+    resourceIds?: string[];
+    kinds?: TelemetryKind[];
+    names?: string[];
+    sources?: string[];
+    levels?: string[];
+    from: string;
+    to: string;
+    text?: string;
+    traceId?: string;
+    requestId?: string;
+    deploymentId?: string;
+    releaseId?: string;
+    workloadId?: string;
+    cursor?: string;
+    limit?: number;
+}
+export interface TelemetryQueryResult {
+    records: TelemetryRecord[];
+    nextCursor?: string;
+    truncated: boolean;
+    scannedRange: {
+        from: string;
+        to: string;
+    };
+    sources: Array<{
+        source: string;
+        latestAt: string;
+        freshness: TelemetryFreshness;
+        count: number;
+    }>;
+    gaps: Array<{
+        from: string;
+        to: string;
+        source?: string;
+    }>;
+}
+export interface TelemetryTailResult {
+    records: TelemetryRecord[];
+    cursor?: string;
+    truncated: boolean;
+}
+export interface TelemetrySeriesQuery extends TelemetryQuery {
+    bucketMs: number;
+    aggregation: TelemetryAggregation;
+    timezone?: string;
+    compareFrom?: string;
+    compareTo?: string;
+}
+export interface TelemetrySeriesPoint {
+    timestamp: string;
+    label: string;
+    value?: number;
+    count: number;
+    gap: boolean;
+}
+export interface TelemetrySeries {
+    name: string;
+    source: string;
+    unit?: string;
+    aggregation: TelemetryAggregation;
+    bucketMs: number;
+    points: TelemetrySeriesPoint[];
+    comparison?: TelemetrySeriesPoint[];
+}
+export interface TelemetryRetentionPolicy {
+    rawDays: number;
+    downsampleAfterDays: number;
+    downsampleBucketMs: number;
+    maxRecords: number;
+}
+export interface TelemetryPolicy extends TelemetryRetentionPolicy {
+    samplingRate: number;
+    collectLogs: boolean;
+    collectTraces: boolean;
+    collectRequestAnalytics: boolean;
+    estimatedStorageUsdPerGbMonth: number;
+}
+export interface TelemetryCollectionStatus {
+    source: string;
+    freshness: TelemetryFreshness;
+    lastObservedAt?: string;
+    lagSeconds?: number;
+    samplingRate: number;
+    retentionDays: number;
+    estimatedDailyBytes: number;
+    estimatedMonthlyCostUsd?: number;
+    message?: string;
+}
+export interface SavedTelemetryQuery {
+    id: string;
+    projectId: string;
+    actorId?: string;
+    name: string;
+    query: TelemetryQuery;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/telemetry/policy.d.ts

@@ -0,0 +1,8 @@
+import type { ControlPlaneStore } from '../control-plane';
+import type { TelemetryPolicy } from './model';
+export declare const DEFAULT_TELEMETRY_POLICY: Readonly<TelemetryPolicy>;
+export declare function normalizeTelemetryPolicy(input: unknown, base?: TelemetryPolicy): TelemetryPolicy;
+export declare function telemetryPolicyKey(projectId: string): string;
+export declare function loadTelemetryPolicy(store: ControlPlaneStore, projectId: string): TelemetryPolicy;
+export declare function saveTelemetryPolicy(store: ControlPlaneStore, projectId: string, input: unknown): TelemetryPolicy;
+export declare function telemetryEstimatedMonthlyCost(estimatedMonthlyBytes: number, policy: TelemetryPolicy): number;

package/dist/telemetry/policy.test.d.ts

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

package/dist/telemetry/redaction.d.ts

@@ -0,0 +1,9 @@
+import type { JsonValue } from '../control-plane';
+export interface TelemetryRedactionOptions {
+    redactEmail?: boolean;
+    redactIp?: boolean;
+    patterns?: RegExp[];
+}
+export declare function redactTelemetryText(value: string, options?: TelemetryRedactionOptions): string;
+export declare function redactTelemetryValue(value: unknown, options?: TelemetryRedactionOptions, key?: string): JsonValue;
+export declare function pathTemplate(value: string | undefined): string | undefined;

package/dist/telemetry/store.d.ts

@@ -0,0 +1,34 @@
+import type { ControlPlaneStore } from '../control-plane';
+import type { AppendTelemetryInput, SavedTelemetryQuery, TelemetryCollectionStatus, TelemetryQuery, TelemetryQueryResult, TelemetryRecord, TelemetryRetentionPolicy, TelemetrySeries, TelemetrySeriesQuery, TelemetryTailResult } from './model';
+import type { TelemetryRedactionOptions } from './redaction';
+export declare function telemetryCursor(record?: Pick<TelemetryRecord, 'timestamp' | 'id'>): string | undefined;
+export declare function telemetryPercentile(values: number[], percentile: number): number | undefined;
+export declare function telemetryBucketLabel(timestamp: Date, timezone?: string): string;
+export declare class TelemetryStore {
+    private readonly controlPlane;
+    private readonly options;
+    constructor(controlPlane: ControlPlaneStore, options?: {
+        now?: () => Date;
+        redaction?: TelemetryRedactionOptions;
+    });
+    private now;
+    append(input: AppendTelemetryInput): TelemetryRecord;
+    appendMany(inputs: AppendTelemetryInput[]): TelemetryRecord[];
+    get(id: string): TelemetryRecord | undefined;
+    query(input: TelemetryQuery): TelemetryQueryResult;
+    tail(input: TelemetryQuery, after?: string): TelemetryTailResult;
+    series(input: TelemetrySeriesQuery): TelemetrySeries[];
+    status(projectId: string, environmentId?: string, retentionDays?: number, samplingRate?: number, resourceIds?: string[]): TelemetryCollectionStatus[];
+    saveQuery(projectId: string, actorId: string | undefined, name: string, query: TelemetryQuery): SavedTelemetryQuery;
+    listSavedQueries(projectId: string, actorId?: string): SavedTelemetryQuery[];
+    deleteSavedQuery(projectId: string, actorId: string | undefined, id: string): boolean;
+    downsample(policy: TelemetryRetentionPolicy, projectId?: string): {
+        compacted: number;
+        rollups: number;
+    };
+    enforceRetention(policy: TelemetryRetentionPolicy, projectId?: string): {
+        deleted: number;
+        compacted: number;
+        rollups: number;
+    };
+}

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

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