@runnee/sdk 0.0.0-stage → 0.1.0

package/lib/esm/types.d.ts

@@ -0,0 +1,304 @@
+export type Error = {
+    statusCode?: number;
+    message?: string | string[];
+    error?: string;
+    code?: string;
+    [key: string]: unknown;
+};
+export type ExecuteRequest = {
+    code: string;
+    mode?: 'dry-run' | 'live';
+    event?: {
+        [key: string]: unknown;
+    };
+    retainSource?: boolean;
+    scriptName?: string;
+    secretNames?: string[];
+    scriptId?: string;
+};
+export type Diagnostic = {
+    code?: string;
+    message: string;
+    line?: number;
+    column?: number;
+    filename?: string;
+    snippet?: string;
+    [key: string]: unknown;
+};
+export type Timings = {
+    [key: string]: number;
+};
+export type ExecutionResult = {
+    durationMs: number;
+    instructions: number;
+    returnValue?: unknown;
+    replies: {
+        count: number;
+        lastPayload?: unknown;
+    };
+    counters?: {
+        dbOps: number;
+        httpCalls: number;
+    };
+    explain?: {
+        [key: string]: unknown;
+    };
+};
+export type ExecuteResponse = {
+    success: boolean;
+    mocked?: boolean;
+    error?: Diagnostic;
+    executionResult?: ExecutionResult;
+    replies?: unknown[];
+    metrics?: {
+        [key: string]: unknown;
+    };
+    telemetryRecorded?: boolean;
+    executionId?: string | null;
+    replayed?: boolean;
+    originalResultOmitted?: boolean;
+    [key: string]: unknown;
+};
+export type Policy = {
+    [key: string]: unknown;
+};
+export type Execution = {
+    id: string;
+    scriptName?: string | null;
+    mode: string;
+    status: string;
+    durationMs: number;
+    instructionsUsed: number;
+    errorCode?: string | null;
+    httpCalls?: number;
+    dbOps?: number;
+    errorMessage?: string | null;
+    hasSource?: boolean;
+    timings?: Timings;
+    createdAt: string;
+    expiresAt?: string;
+    [key: string]: unknown;
+};
+export type ExecutionDetail = {
+    id: string;
+    scriptName?: string | null;
+    mode: string;
+    status: string;
+    durationMs: number;
+    instructionsUsed: number;
+    errorCode?: string | null;
+    httpCalls?: number;
+    dbOps?: number;
+    errorMessage?: string | null;
+    hasSource?: boolean;
+    timings?: Timings;
+    createdAt: string;
+    expiresAt?: string;
+    sourceCode?: string | null;
+    outputPreview?: string | null;
+    [key: string]: unknown;
+};
+export type ExecutionPage = {
+    items: Execution[];
+    nextCursor: string | null;
+    policy: Policy;
+};
+export type Script = {
+    id: string;
+    name: string;
+    currentVersion: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ScriptDetail = {
+    id: string;
+    name: string;
+    currentVersion: number;
+    createdAt: string;
+    updatedAt: string;
+    code: string;
+    versions: {
+        version: number;
+        createdAt: string;
+        bytes: number;
+    }[];
+    [key: string]: unknown;
+};
+export type ScriptList = {
+    items: Script[];
+    policy: Policy;
+};
+export type ScriptCreate = {
+    name: string;
+    code: string;
+};
+export type ScriptUpdate = {
+    name: string;
+    code: string;
+    expectedVersion: number;
+};
+export type ScriptRestore = {
+    version: number;
+    expectedVersion: number;
+};
+export type ScriptVersion = {
+    version: number;
+    code: string;
+    createdAt: string;
+};
+export type Deleted = {
+    deleted: boolean;
+};
+export type Storage = {
+    policy: Policy;
+    history: {
+        count: number;
+        bytes: number;
+    };
+    scripts: {
+        count: number;
+        versions: number;
+        bytes: number;
+    };
+};
+export type Secret = {
+    name: string;
+    allowInline: boolean;
+    scriptIds: string[];
+    version: number;
+    createdAt: string;
+    updatedAt: string;
+};
+export type SecretList = {
+    items: Secret[];
+};
+export type SecretCreate = {
+    name: string;
+    value: string;
+    allowInline?: boolean;
+    scriptIds?: string[];
+};
+export type SecretUpdate = {
+    value?: string;
+    allowInline?: boolean;
+    scriptIds?: string[];
+};
+export type SandboxLimits = {
+    timeoutMs: number;
+    maxInstructions: number;
+    maxMemoryMb: number;
+};
+export type Sandbox = {
+    plan: string;
+    configurable: boolean;
+    limits: SandboxLimits;
+    defaults: SandboxLimits;
+    maxLimits: SandboxLimits;
+};
+export type Plan = {
+    id: string;
+    configurable?: boolean;
+    limits: SandboxLimits;
+    maxLimits?: SandboxLimits;
+    name: string;
+    monthlyUsd?: number | null;
+    yearlyMonthlyUsd?: number | null;
+    usageUsdPer1k?: number;
+    executionsPerMonth: number | null;
+    timeoutMs?: number;
+    features?: string[];
+    [key: string]: unknown;
+};
+export type Plans = {
+    configured: boolean;
+    plans: Plan[];
+};
+export type BillingStatus = {
+    configured: boolean;
+    plan: Plan;
+    subscription: {
+        status?: string;
+        interval?: string | null;
+        currentPeriodEnd?: string | null;
+        cancelAtPeriodEnd?: boolean;
+        hasCustomer?: boolean;
+        [key: string]: unknown;
+    } | null;
+    usage: {
+        executions: number;
+        limit: number | null;
+        resetsAt: string;
+    };
+};
+export type UsageSummary = {
+    windowDays: number;
+    totalExecutions: number;
+    successfulExecutions: number;
+    failedExecutions: number;
+    averageDurationMs: number;
+    latest: {
+        [key: string]: unknown;
+    }[];
+};
+export type UsageHistory = {
+    days: number;
+    total: number;
+    success: number;
+    failed: number;
+    successRate: number;
+    daily: {
+        date: string;
+        total: number;
+        success: number;
+        failed: number;
+        avgDurationMs: number;
+    }[];
+    topScripts: {
+        name: string;
+        count: number;
+    }[];
+    topScriptsSample: {
+        days: number;
+        limit: number;
+    };
+    apiKeys: {
+        active: number;
+        lastUsedAt: string | null;
+    };
+};
+export type TelemetryExecution = {
+    scriptName?: string;
+    mode?: string;
+    status: string;
+    durationMs: number;
+    instructionsUsed: number;
+    memoryUsageKb?: number;
+    errorCode?: string;
+    metadata?: {
+        [key: string]: unknown;
+    };
+};
+export type TelemetryEvent = {
+    eventName: string;
+    pagePath?: string;
+    sessionId?: string;
+    fingerprintHash?: string;
+    properties?: {
+        [key: string]: string | number | boolean | null;
+    };
+};
+export type TelemetryRecorded = {
+    [key: string]: unknown;
+} | string | null;
+export type Accepted = {
+    accepted: boolean;
+};
+export type Health = {
+    status: 'operational' | 'degraded';
+    timestamp: string;
+    services: {
+        id: string;
+        name: string;
+        status: 'operational' | 'degraded';
+    }[];
+};

package/lib/esm/types.js

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

package/lib/esm/validation.d.ts

@@ -0,0 +1,3 @@
+export declare function validate(value: unknown, name: string, response: boolean, requestId?: string): void;
+/** Reject non-JSON inputs before I/O; serialization failures must never look retryable. */
+export declare function encodeRequest(value: unknown): string;

package/lib/esm/validation.js

@@ -0,0 +1,98 @@
+import { contracts } from './contracts.js';
+import { RunneeResponseError, RunneeValidationError } from './errors.js';
+const schemas = contracts.schemas;
+function valid(value, s, depth = 0) {
+    if (depth > 40)
+        return false;
+    if (s.$ref)
+        return valid(value, schemas[s.$ref.split('/').pop()], depth + 1);
+    if (s.anyOf)
+        return s.anyOf.some((sub) => valid(value, sub, depth + 1));
+    if (s.enum && !s.enum.includes(value))
+        return false;
+    if (s.type === 'null')
+        return value === null;
+    if (s.type === 'boolean')
+        return typeof value === 'boolean';
+    if (s.type === 'number' || s.type === 'integer')
+        return (typeof value === 'number' &&
+            Number.isFinite(value) &&
+            (s.type !== 'integer' || Number.isSafeInteger(value)) &&
+            (s.minimum === undefined || value >= s.minimum) &&
+            (s.maximum === undefined || value <= s.maximum));
+    if (s.type === 'string')
+        return (typeof value === 'string' &&
+            (s.minLength === undefined || value.length >= s.minLength) &&
+            (s.maxLength === undefined || value.length <= s.maxLength) &&
+            (!s.pattern || new RegExp(s.pattern).test(value)) &&
+            (s.format !== 'uuid' || /^[a-f\d]{8}-(?:[a-f\d]{4}-){3}[a-f\d]{12}$/i.test(value)));
+    if (s.type === 'array')
+        return (Array.isArray(value) &&
+            (s.minItems === undefined || value.length >= s.minItems) &&
+            (s.maxItems === undefined || value.length <= s.maxItems) &&
+            (!s.uniqueItems || new Set(value.map((v) => JSON.stringify(v))).size === value.length) &&
+            value.every((v) => valid(v, s.items ?? {}, depth + 1)));
+    if (s.type === 'object') {
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            return false;
+        const record = value;
+        return ((!s.minProperties || Object.keys(record).length >= s.minProperties) &&
+            (s.required ?? []).every((k) => Object.hasOwn(record, k)) &&
+            Object.entries(record).every(([k, v]) => Object.hasOwn(s.properties ?? {}, k)
+                ? valid(v, s.properties[k], depth + 1)
+                : s.additionalProperties === false
+                    ? false
+                    : typeof s.additionalProperties === 'object'
+                        ? valid(v, s.additionalProperties, depth + 1)
+                        : true));
+    }
+    return true;
+}
+export function validate(value, name, response, requestId) {
+    if (!schemas[name] || !valid(value, schemas[name])) {
+        const ErrorClass = response ? RunneeResponseError : RunneeValidationError;
+        throw new ErrorClass(response
+            ? 'Runnee returned an unexpected response.'
+            : 'Request does not match the Runnee API contract.', { requestId });
+    }
+}
+/** Reject non-JSON inputs before I/O; serialization failures must never look retryable. */
+export function encodeRequest(value) {
+    const ancestors = new Set();
+    let count = 0, characters = 0;
+    const walk = (v, depth = 0) => {
+        if (++count > 10000 || depth > 20)
+            throw new RunneeValidationError('Request JSON exceeds the nesting or value limit.');
+        if (v === null || typeof v === 'boolean')
+            return;
+        if (typeof v === 'string') {
+            characters += v.length;
+            if (characters > 102400)
+                throw new RunneeValidationError('Request JSON is too large.');
+            return;
+        }
+        if (typeof v === 'number' && Number.isFinite(v))
+            return;
+        if (v &&
+            typeof v === 'object' &&
+            (Array.isArray(v) ||
+                Object.getPrototypeOf(v) === Object.prototype ||
+                Object.getPrototypeOf(v) === null)) {
+            if (ancestors.has(v))
+                throw new RunneeValidationError('Request JSON contains a cycle.');
+            ancestors.add(v);
+            for (const [key, entry] of Object.entries(v)) {
+                characters += key.length;
+                walk(entry, depth + 1);
+            }
+            ancestors.delete(v);
+            return;
+        }
+        throw new RunneeValidationError('Request data must contain only JSON values.');
+    };
+    walk(value);
+    const encoded = JSON.stringify(value);
+    if (new TextEncoder().encode(encoded).byteLength > 102400)
+        throw new RunneeValidationError('Request JSON exceeds 100 KiB.');
+    return encoded;
+}