@sequenceholdings/managed-functions 0.1.1

package/dist/limits.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MF_LIMITS_DEFAULTS = exports.MF_LIMITS_CAPS = exports.managedFunctionWorkloadLimitsSchema = exports.MANAGED_FUNCTION_LIMITS = void 0;
+const zod_1 = require("zod");
+exports.MANAGED_FUNCTION_LIMITS = {
+    environment: {
+        functions: { max: 100, scope: 'Non-archived functions across all organizations; undeployed shells count' },
+    },
+    workload: {
+        memory_mb: { min: 128, max: 2048, default: 256, unit: 'MiB per instance' },
+        timeout_seconds: { min: 1, max: 540, default: 60, unit: 'seconds' },
+        min_instances: { min: 0, max: 10, default: 1, scope: 'Cannot exceed max_instances; warm instances incur idle charges' },
+        max_instances: { min: 2, max: 10, default: 3, scope: 'Autoscaling ceiling; must allow at least two instances, and GCP may temporarily exceed it' },
+        invoke_rate_per_minute: { min: 1, max: 600, default: 60, window_seconds: 60, scope: 'Per function across all Atlas replicas in the environment; Redis-backed fixed window. Redis unavailability rejects invocations (503); key loss resets the window' },
+        max_request_bytes: { max: 1024 * 1024, unit: 'bytes', configurable: false },
+        max_response_bytes: { max: 4 * 1024 * 1024, unit: 'bytes', configurable: false },
+        cpu: {
+            configurable: true, default: 'auto', min: 1, max: 2,
+            min_memory_mb_for_multiple_cpus: 512,
+            scope: 'auto uses provider memory-derived allocation; explicit CPU must be a whole vCPU. Multiple CPUs require the minimum memory listed here',
+        },
+        concurrency: {
+            configurable: true, min: 1, max: 80, default: 1,
+            scope: 'Simultaneous requests per instance; values above 1 require explicit cpu (not auto). Requests share instance CPU and memory',
+        },
+    },
+    cache: {
+        enabled: { default: false },
+        tier: { allowed: ['custom-pico', 'custom-micro', 'custom-mini'], default: 'custom-pico' },
+        replicas: { min: 0, max: 5, default: 0 },
+        default_ttl_seconds: { min: 1, max: 86400, default: 30, unit: 'seconds' },
+        max_key_bytes: { max: 512, unit: 'bytes' },
+        max_value_bytes: { max: 1024 * 1024, unit: 'bytes' },
+    },
+    bundle: {
+        files: { max: 2000 },
+        file_bytes: { max: 5 * 1024 * 1024, unit: 'bytes' },
+        source_bytes: { max: 25 * 1024 * 1024, unit: 'bytes unpacked' },
+        request_bytes: { max: 32 * 1024 * 1024, unit: 'bytes in deploy request' },
+    },
+};
+function integerLimit(limit) {
+    return zod_1.z.number().int().min(limit.min).max(limit.max).default(limit.default);
+}
+const workload = exports.MANAGED_FUNCTION_LIMITS.workload;
+exports.managedFunctionWorkloadLimitsSchema = zod_1.z.object({
+    memory_mb: integerLimit(workload.memory_mb),
+    cpu: zod_1.z.union([
+        zod_1.z.literal(workload.cpu.default),
+        zod_1.z.number().int().min(workload.cpu.min).max(workload.cpu.max),
+    ]).default(workload.cpu.default),
+    concurrency: integerLimit(workload.concurrency),
+    timeout_seconds: integerLimit(workload.timeout_seconds),
+    min_instances: integerLimit(workload.min_instances),
+    max_instances: integerLimit(workload.max_instances),
+    invoke_rate_per_minute: integerLimit(workload.invoke_rate_per_minute),
+}).superRefine((limits, ctx) => {
+    if (limits.cpu === 'auto' && limits.concurrency > 1) {
+        ctx.addIssue({
+            code: 'custom', path: ['concurrency'],
+            message: 'concurrency above 1 requires an explicit cpu allocation; auto may allocate a fractional CPU',
+        });
+    }
+    if (typeof limits.cpu === 'number' && limits.cpu > 1 && limits.memory_mb < workload.cpu.min_memory_mb_for_multiple_cpus) {
+        ctx.addIssue({
+            code: 'custom', path: ['memory_mb'],
+            message: `Multiple CPUs require at least ${workload.cpu.min_memory_mb_for_multiple_cpus} MiB of memory`,
+        });
+    }
+    if (limits.min_instances > limits.max_instances) {
+        ctx.addIssue({
+            code: 'custom',
+            message: 'min_instances cannot exceed max_instances',
+            path: ['min_instances'],
+        });
+    }
+}).prefault({});
+exports.MF_LIMITS_CAPS = {
+    cpu: workload.cpu.max,
+    concurrency: workload.concurrency.max,
+    memoryMb: workload.memory_mb.max,
+    timeoutSeconds: workload.timeout_seconds.max,
+    maxInstances: workload.max_instances.max,
+    invokeRatePerMinute: workload.invoke_rate_per_minute.max,
+    maxRequestBytes: workload.max_request_bytes.max,
+    maxResponseBytes: workload.max_response_bytes.max,
+};
+exports.MF_LIMITS_DEFAULTS = {
+    cpu: workload.cpu.default,
+    concurrency: workload.concurrency.default,
+    memoryMb: workload.memory_mb.default,
+    timeoutSeconds: workload.timeout_seconds.default,
+    minInstances: workload.min_instances.default,
+    maxInstances: workload.max_instances.default,
+    invokeRatePerMinute: workload.invoke_rate_per_minute.default,
+    maxRequestBytes: workload.max_request_bytes.max,
+    maxResponseBytes: workload.max_response_bytes.max,
+};

package/dist/memory.d.ts

@@ -0,0 +1,22 @@
+import { type CacheStore } from './cache';
+export declare class MemoryStore implements CacheStore {
+    private readonly entries;
+    private used;
+    private readonly maxBytes;
+    private readonly now;
+    private readonly maxEntries;
+    constructor({ maxBytes, now, }?: {
+        maxBytes?: number;
+        now?: () => number;
+    });
+    get bytes(): number;
+    get(key: string): Promise<string | null>;
+    set({ key, value, ttlSeconds, onlyIfAbsent, }: {
+        key: string;
+        value: string;
+        ttlSeconds: number;
+        onlyIfAbsent: boolean;
+    }): Promise<boolean>;
+    delete(key: string): Promise<boolean>;
+    private remove;
+}

package/dist/memory.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStore = void 0;
+const cache_1 = require("./cache");
+class MemoryStore {
+    entries = new Map();
+    used = 0;
+    maxBytes;
+    now;
+    maxEntries = 10000;
+    constructor({ maxBytes = 16 * 1024 * 1024, now = Date.now, } = {}) {
+        this.maxBytes = maxBytes;
+        this.now = now;
+    }
+    get bytes() {
+        return this.used;
+    }
+    async get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return null;
+        if (entry.expiresAt <= this.now()) {
+            this.remove(key);
+            return null;
+        }
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry.value;
+    }
+    async set({ key, value, ttlSeconds, onlyIfAbsent, }) {
+        const existing = this.entries.get(key);
+        if (onlyIfAbsent && existing && existing.expiresAt > this.now())
+            return false;
+        const bytes = Buffer.byteLength(key) + Buffer.byteLength(value);
+        if (bytes > this.maxBytes)
+            throw new cache_1.CacheError('INVALID_VALUE');
+        this.remove(key);
+        while (this.used + bytes > this.maxBytes ||
+            this.entries.size >= this.maxEntries) {
+            const first = this.entries.keys().next().value;
+            if (first === undefined)
+                break;
+            this.remove(first);
+        }
+        this.entries.set(key, {
+            value,
+            expiresAt: this.now() + ttlSeconds * 1000,
+            bytes,
+        });
+        this.used += bytes;
+        return true;
+    }
+    async delete(key) {
+        const entry = this.entries.get(key);
+        const exists = !!entry && entry.expiresAt > this.now();
+        this.remove(key);
+        return exists;
+    }
+    remove(key) {
+        const entry = this.entries.get(key);
+        if (entry) {
+            this.used -= entry.bytes;
+            this.entries.delete(key);
+        }
+    }
+}
+exports.MemoryStore = MemoryStore;