@mizchi/k1c 0.1.0

package/dist/providers/worker.js

@@ -0,0 +1,430 @@
+import { z } from 'zod';
+import { NotFound } from "./types.js";
+import { toProviderError } from "./errors.js";
+export const workerSchema = z.object({
+    scriptName: z.string(),
+    entrypoint: z.string(),
+    compatibilityDate: z.string(),
+    compatibilityFlags: z.array(z.string()).optional(),
+    vars: z.record(z.string()).optional(),
+    secrets: z.record(z.string()).optional(),
+    bindings: z
+        .array(z.discriminatedUnion('type', [
+        z.object({
+            type: z.literal('r2_bucket'),
+            name: z.string(),
+            bucketName: z.string(),
+        }),
+        z.object({
+            type: z.literal('kv_namespace'),
+            name: z.string(),
+            namespaceId: z.string(),
+        }),
+        z.object({
+            type: z.literal('service'),
+            name: z.string(),
+            service: z.string(),
+        }),
+        z.object({
+            type: z.literal('dispatch_namespace'),
+            name: z.string(),
+            dispatchNamespace: z.string(),
+        }),
+        z.object({
+            type: z.literal('hyperdrive'),
+            name: z.string(),
+            hyperdriveId: z.string(),
+        }),
+        z.object({
+            type: z.literal('d1'),
+            name: z.string(),
+            databaseId: z.string(),
+        }),
+        z.object({
+            type: z.literal('queue'),
+            name: z.string(),
+            queueName: z.string(),
+        }),
+        z.object({
+            type: z.literal('durable_object_namespace'),
+            name: z.string(),
+            className: z.string(),
+            scriptName: z.string().optional(),
+        }),
+        z.object({
+            type: z.literal('vectorize'),
+            name: z.string(),
+            indexName: z.string(),
+        }),
+        z.object({ type: z.literal('ai'), name: z.string() }),
+        z.object({ type: z.literal('browser'), name: z.string() }),
+        z.object({ type: z.literal('version_metadata'), name: z.string() }),
+        z.object({
+            type: z.literal('analytics_engine'),
+            name: z.string(),
+            dataset: z.string(),
+        }),
+    ]))
+        .optional(),
+    observability: z.object({ enabled: z.boolean() }).optional(),
+    placement: z.object({ mode: z.literal('smart') }).optional(),
+    dispatchNamespace: z.string().optional(),
+    entrypointContent: z.string().optional(),
+    entrypointHash: z.string().optional(),
+    cronSchedules: z.array(z.string()).optional(),
+    durableObjectClasses: z.array(z.string()).optional(),
+});
+const NAME_PREFIX = 'k1c--';
+const SEPARATOR = '--';
+const MAIN_MODULE = 'worker.mjs';
+function parseLabel(scriptName) {
+    if (!scriptName.startsWith(NAME_PREFIX))
+        return null;
+    const rest = scriptName.slice(NAME_PREFIX.length);
+    const sepIdx = rest.indexOf(SEPARATOR);
+    if (sepIdx <= 0 || sepIdx + SEPARATOR.length === rest.length)
+        return null;
+    const namespace = rest.slice(0, sepIdx);
+    const name = rest.slice(sepIdx + SEPARATOR.length);
+    if (!name)
+        return null;
+    return `${namespace}/${name}`;
+}
+function buildBindings(props) {
+    const out = [];
+    for (const [name, text] of Object.entries(props.vars ?? {})) {
+        out.push({ type: 'plain_text', name, text });
+    }
+    for (const [name, text] of Object.entries(props.secrets ?? {})) {
+        out.push({ type: 'secret_text', name, text });
+    }
+    for (const b of props.bindings ?? []) {
+        if (b.type === 'r2_bucket') {
+            out.push({ type: 'r2_bucket', name: b.name, bucket_name: b.bucketName });
+        }
+        else if (b.type === 'kv_namespace') {
+            out.push({ type: 'kv_namespace', name: b.name, namespace_id: b.namespaceId });
+        }
+        else if (b.type === 'service') {
+            out.push({ type: 'service', name: b.name, service: b.service });
+        }
+        else if (b.type === 'dispatch_namespace') {
+            out.push({ type: 'dispatch_namespace', name: b.name, namespace: b.dispatchNamespace });
+        }
+        else if (b.type === 'hyperdrive') {
+            out.push({ type: 'hyperdrive', name: b.name, id: b.hyperdriveId });
+        }
+        else if (b.type === 'd1') {
+            out.push({ type: 'd1', name: b.name, id: b.databaseId });
+        }
+        else if (b.type === 'queue') {
+            out.push({ type: 'queue', name: b.name, queue_name: b.queueName });
+        }
+        else if (b.type === 'durable_object_namespace') {
+            out.push({
+                type: 'durable_object_namespace',
+                name: b.name,
+                class_name: b.className,
+                ...(b.scriptName !== undefined ? { script_name: b.scriptName } : {}),
+            });
+        }
+        else if (b.type === 'vectorize') {
+            out.push({ type: 'vectorize', name: b.name, index_name: b.indexName });
+        }
+        else if (b.type === 'ai' || b.type === 'browser' || b.type === 'version_metadata') {
+            out.push({ type: b.type, name: b.name });
+        }
+        else if (b.type === 'analytics_engine') {
+            out.push({ type: 'analytics_engine', name: b.name, dataset: b.dataset });
+        }
+    }
+    return out;
+}
+const CONTENT_HASH_TAG_PREFIX = 'k1c.io/content-hash=';
+const DO_CLASSES_TAG_PREFIX = 'k1c.io/do-classes=';
+function buildMetadata(ctx, props) {
+    const tags = [ctx.managedByLabel];
+    if (props.entrypointHash !== undefined) {
+        tags.push(`${CONTENT_HASH_TAG_PREFIX}${props.entrypointHash}`);
+    }
+    const classes = [...(props.durableObjectClasses ?? [])].sort();
+    if (classes.length > 0) {
+        tags.push(`${DO_CLASSES_TAG_PREFIX}${classes.join(',')}`);
+    }
+    // Auto-include self-pointing DO bindings for every declared class so the Worker
+    // can address its own DO instances by name (e.g. `env.<class>.idFromName(id)`).
+    const selfDoBindings = classes.map((className) => ({
+        type: 'durable_object_namespace',
+        name: className,
+        className,
+    }));
+    const allBindings = buildBindings({
+        ...props,
+        bindings: [...(props.bindings ?? []), ...selfDoBindings],
+    });
+    return {
+        main_module: MAIN_MODULE,
+        compatibility_date: props.compatibilityDate,
+        ...(props.compatibilityFlags !== undefined
+            ? { compatibility_flags: [...props.compatibilityFlags] }
+            : {}),
+        bindings: allBindings,
+        tags,
+        ...(props.observability !== undefined
+            ? { observability: { enabled: props.observability.enabled } }
+            : {}),
+        ...(props.placement !== undefined ? { placement: { mode: props.placement.mode } } : {}),
+        ...(classes.length > 0
+            ? {
+                migrations: {
+                    new_sqlite_classes: classes,
+                    new_tag: props.entrypointHash ?? 'k1c-initial',
+                },
+            }
+            : {}),
+    };
+}
+function extractContentHash(tags) {
+    if (!tags)
+        return undefined;
+    for (const tag of tags) {
+        if (tag.startsWith(CONTENT_HASH_TAG_PREFIX))
+            return tag.slice(CONTENT_HASH_TAG_PREFIX.length);
+    }
+    return undefined;
+}
+function extractDoClasses(tags) {
+    if (!tags)
+        return undefined;
+    for (const tag of tags) {
+        if (tag.startsWith(DO_CLASSES_TAG_PREFIX)) {
+            const list = tag.slice(DO_CLASSES_TAG_PREFIX.length);
+            if (!list)
+                return undefined;
+            return list.split(',').filter((s) => s.length > 0);
+        }
+    }
+    return undefined;
+}
+async function readEntrypoint(ctx, props) {
+    if (props.entrypointContent !== undefined) {
+        return new TextEncoder().encode(props.entrypointContent);
+    }
+    const reader = ctx.readFile ??
+        (async (p) => {
+            const fs = await import('node:fs/promises');
+            return fs.readFile(p);
+        });
+    return reader(props.entrypoint);
+}
+async function uploadAndDeploy(ctx, props) {
+    if (props.dispatchNamespace !== undefined) {
+        return uploadToDispatchNamespace(ctx, props, props.dispatchNamespace);
+    }
+    return uploadVersionAndDeploy(ctx, props);
+}
+async function uploadVersionAndDeploy(ctx, props) {
+    const content = await readEntrypoint(ctx, props);
+    const file = new File([content], MAIN_MODULE, { type: 'application/javascript+module' });
+    // 1. Upload a new immutable version (does not deploy to traffic).
+    const versionResult = await ctx.cloudflare.workers.scripts.versions.create(props.scriptName, {
+        account_id: ctx.accountId,
+        metadata: buildMetadata(ctx, props),
+        [MAIN_MODULE]: [file],
+    });
+    const versionId = versionResult.id;
+    if (!versionId) {
+        throw new Error('versions.create did not return a version id');
+    }
+    // 2. Cut over: route 100% of traffic to the new version (cutover semantics).
+    // canary.steps and blueGreen with manual promotion are not yet implemented (v0.1.2).
+    await ctx.cloudflare.workers.scripts.deployments.create(props.scriptName, {
+        account_id: ctx.accountId,
+        strategy: 'percentage',
+        versions: [{ version_id: versionId, percentage: 100 }],
+    });
+    // 3. Sync cron triggers if the manifest declared any (CronJob path).
+    await syncCronSchedules(ctx, props);
+    return { scriptId: props.scriptName, versionId };
+}
+async function syncCronSchedules(ctx, props) {
+    const schedules = props.cronSchedules ?? [];
+    await ctx.cloudflare.workers.scripts.schedules.update(props.scriptName, {
+        account_id: ctx.accountId,
+        body: schedules.map((cron) => ({ cron })),
+    });
+}
+async function uploadToDispatchNamespace(ctx, props, dispatchNamespace) {
+    const content = await readEntrypoint(ctx, props);
+    const file = new File([content], MAIN_MODULE, { type: 'application/javascript+module' });
+    // Dispatch-namespace scripts do not currently flow through the Versions/Deployments API.
+    // The dispatcher Worker invokes them by name on each request, so a single mutable script
+    // per name is the right model.
+    await ctx.cloudflare.workersForPlatforms.dispatch.namespaces.scripts.update(dispatchNamespace, props.scriptName, {
+        account_id: ctx.accountId,
+        metadata: buildMetadata(ctx, props),
+        files: { [MAIN_MODULE]: file },
+    });
+    return { scriptId: props.scriptName, versionId: 'dispatched' };
+}
+function fromCFBinding(b) {
+    if (b.type === 'r2_bucket' && b.bucket_name !== undefined) {
+        return { type: 'r2_bucket', name: b.name, bucketName: b.bucket_name };
+    }
+    if (b.type === 'kv_namespace' && b.namespace_id !== undefined) {
+        return { type: 'kv_namespace', name: b.name, namespaceId: b.namespace_id };
+    }
+    if (b.type === 'service' && b.service !== undefined) {
+        return { type: 'service', name: b.name, service: b.service };
+    }
+    if (b.type === 'dispatch_namespace' && b.namespace !== undefined) {
+        return { type: 'dispatch_namespace', name: b.name, dispatchNamespace: b.namespace };
+    }
+    if (b.type === 'hyperdrive' && b.id !== undefined) {
+        return { type: 'hyperdrive', name: b.name, hyperdriveId: b.id };
+    }
+    if (b.type === 'd1' && b.id !== undefined) {
+        return { type: 'd1', name: b.name, databaseId: b.id };
+    }
+    if (b.type === 'queue' && b.queue_name !== undefined) {
+        return { type: 'queue', name: b.name, queueName: b.queue_name };
+    }
+    if (b.type === 'durable_object_namespace' && b.class_name !== undefined) {
+        return {
+            type: 'durable_object_namespace',
+            name: b.name,
+            className: b.class_name,
+            ...(b.script_name !== undefined ? { scriptName: b.script_name } : {}),
+        };
+    }
+    if (b.type === 'vectorize' && b.index_name !== undefined) {
+        return { type: 'vectorize', name: b.name, indexName: b.index_name };
+    }
+    if (b.type === 'ai' || b.type === 'browser' || b.type === 'version_metadata') {
+        return { type: b.type, name: b.name };
+    }
+    if (b.type === 'analytics_engine' && b.dataset !== undefined) {
+        return { type: 'analytics_engine', name: b.name, dataset: b.dataset };
+    }
+    return null;
+}
+export const workerProvider = {
+    resourceType: 'Worker',
+    schema: workerSchema,
+    async *list(ctx) {
+        let iter;
+        try {
+            iter = ctx.cloudflare.workers.scripts.list({ account_id: ctx.accountId });
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+        try {
+            for await (const script of iter) {
+                const id = script.id;
+                if (!id)
+                    continue;
+                const label = parseLabel(id);
+                if (label === null)
+                    continue;
+                yield { nativeId: id, label };
+            }
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async read(ctx, nativeId) {
+        let response;
+        try {
+            response = await ctx.cloudflare.workers.scripts.scriptAndVersionSettings.get(nativeId, {
+                account_id: ctx.accountId,
+            });
+        }
+        catch (raw) {
+            const err = toProviderError(raw);
+            if (err.code === 'NotFound')
+                return NotFound;
+            throw err;
+        }
+        const settings = response;
+        const entrypointHash = extractContentHash(settings.tags);
+        const durableObjectClasses = extractDoClasses(settings.tags);
+        let cronSchedules;
+        try {
+            const sched = await ctx.cloudflare.workers.scripts.schedules.get(nativeId, {
+                account_id: ctx.accountId,
+            });
+            const list = sched.schedules ?? [];
+            const crons = list.map((s) => s.cron).filter((c) => typeof c === 'string');
+            if (crons.length > 0)
+                cronSchedules = crons;
+        }
+        catch {
+            // schedules.get may fail (no triggers, transient error) — treat as no schedules.
+        }
+        const vars = {};
+        const bindings = [];
+        for (const b of settings.bindings ?? []) {
+            if (b.type === 'plain_text' && b.text !== undefined) {
+                vars[b.name] = b.text;
+                continue;
+            }
+            if (b.type === 'secret_text') {
+                // Secret values are never returned by Cloudflare; skip silently.
+                continue;
+            }
+            const translated = fromCFBinding(b);
+            if (translated !== null)
+                bindings.push(translated);
+        }
+        const props = {
+            scriptName: nativeId,
+            entrypoint: '<read-from-cluster>',
+            compatibilityDate: settings.compatibility_date ?? '2025-01-01',
+            ...(settings.compatibility_flags !== undefined
+                ? { compatibilityFlags: settings.compatibility_flags }
+                : {}),
+            ...(Object.keys(vars).length > 0 ? { vars } : {}),
+            ...(bindings.length > 0 ? { bindings } : {}),
+            ...(settings.observability?.enabled !== undefined
+                ? { observability: { enabled: settings.observability.enabled } }
+                : {}),
+            ...(settings.placement?.mode === 'smart'
+                ? { placement: { mode: 'smart' } }
+                : {}),
+            ...(entrypointHash !== undefined ? { entrypointHash } : {}),
+            ...(cronSchedules !== undefined ? { cronSchedules } : {}),
+            ...(durableObjectClasses !== undefined ? { durableObjectClasses } : {}),
+        };
+        return props;
+    },
+    async create(ctx, _label, desired) {
+        try {
+            const { scriptId } = await uploadAndDeploy(ctx, desired);
+            return { kind: 'sync', nativeId: scriptId, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async update(ctx, _nativeId, _prior, desired) {
+        try {
+            const { scriptId } = await uploadAndDeploy(ctx, desired);
+            return { kind: 'sync', nativeId: scriptId, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async delete(ctx, nativeId) {
+        try {
+            await ctx.cloudflare.workers.scripts.delete(nativeId, { account_id: ctx.accountId });
+            return { kind: 'sync' };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+};
+//# sourceMappingURL=worker.js.map

package/dist/providers/workflow.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import type { CloudflareResourceProvider } from './types.ts';
+export interface WorkflowProperties {
+    readonly workflowName: string;
+    readonly className: string;
+    readonly scriptName: string;
+}
+export declare const workflowPropsSchema: z.ZodType<WorkflowProperties>;
+export declare const workflowProvider: CloudflareResourceProvider<WorkflowProperties>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/providers/workflow.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { NotFound } from "./types.js";
+import { toProviderError } from "./errors.js";
+export const workflowPropsSchema = z.object({
+    workflowName: z.string(),
+    className: z.string(),
+    scriptName: z.string(),
+});
+const NAME_PREFIX = 'k1c-';
+function parseLabel(name) {
+    if (!name.startsWith(NAME_PREFIX))
+        return null;
+    const rest = name.slice(NAME_PREFIX.length);
+    const dash = rest.indexOf('-');
+    if (dash <= 0 || dash === rest.length - 1)
+        return null;
+    return `${rest.slice(0, dash)}/${rest.slice(dash + 1)}`;
+}
+export const workflowProvider = {
+    resourceType: 'Workflow',
+    schema: workflowPropsSchema,
+    async *list(ctx) {
+        let iter;
+        try {
+            iter = ctx.cloudflare.workflows.list({ account_id: ctx.accountId });
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+        try {
+            for await (const wf of iter) {
+                const name = wf.name;
+                if (!name)
+                    continue;
+                const label = parseLabel(name);
+                if (label === null)
+                    continue;
+                // Workflows are addressed by name, not by a separate id.
+                yield { nativeId: name, label };
+            }
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async read(ctx, nativeId) {
+        try {
+            const wf = await ctx.cloudflare.workflows.get(nativeId, { account_id: ctx.accountId });
+            const w = wf;
+            if (!w.name || !w.class_name || !w.script_name)
+                return NotFound;
+            return {
+                workflowName: w.name,
+                className: w.class_name,
+                scriptName: w.script_name,
+            };
+        }
+        catch (raw) {
+            const err = toProviderError(raw);
+            if (err.code === 'NotFound')
+                return NotFound;
+            throw err;
+        }
+    },
+    async create(ctx, _label, desired) {
+        // Cloudflare's Workflow registration uses PUT (the `update` method) for both
+        // create and update — there is no separate POST endpoint.
+        try {
+            await ctx.cloudflare.workflows.update(desired.workflowName, {
+                account_id: ctx.accountId,
+                class_name: desired.className,
+                script_name: desired.scriptName,
+            });
+            return { kind: 'sync', nativeId: desired.workflowName, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async update(ctx, nativeId, _prior, desired) {
+        try {
+            await ctx.cloudflare.workflows.update(nativeId, {
+                account_id: ctx.accountId,
+                class_name: desired.className,
+                script_name: desired.scriptName,
+            });
+            return { kind: 'sync', nativeId, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async delete(ctx, nativeId) {
+        try {
+            await ctx.cloudflare.workflows.delete(nativeId, { account_id: ctx.accountId });
+            return { kind: 'sync' };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+};
+//# sourceMappingURL=workflow.js.map

package/dist/reconciler/apply.d.ts

@@ -0,0 +1,10 @@
+import type { ProviderContext } from '../providers/types.ts';
+import type { ProviderRegistry } from '../providers/registry.ts';
+import type { ApplyReport, Plan } from './types.ts';
+export interface ApplyOptions {
+    readonly retries?: number;
+    readonly backoffMs?: number;
+    readonly dryRun?: boolean;
+}
+export declare function apply(plan: Plan, registry: ProviderRegistry, ctx: ProviderContext, options?: ApplyOptions): Promise<ApplyReport>;
+//# sourceMappingURL=apply.d.ts.map

package/dist/reconciler/apply.js

@@ -0,0 +1,114 @@
+const DEFAULT_OPTIONS = {
+    retries: 3,
+    backoffMs: 200,
+    dryRun: false,
+};
+export async function apply(plan, registry, ctx, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    // plan() returns operations already topologically ordered:
+    // (creates+updates in dependency order) → noops → deletes.
+    // apply runs them in that order; hand-constructed plans take responsibility for ordering.
+    const results = [];
+    let aborted = false;
+    for (const op of plan.operations) {
+        if (aborted) {
+            results.push({ op, status: 'skipped' });
+            continue;
+        }
+        if (opts.dryRun) {
+            results.push({ op, status: 'skipped' });
+            continue;
+        }
+        if (op.kind === 'noop') {
+            results.push({ op, status: 'succeeded' });
+            continue;
+        }
+        const result = await runOperation(op, registry, ctx, opts);
+        results.push(result);
+        if (result.status === 'failed')
+            aborted = true;
+    }
+    return summarize(results);
+}
+async function runOperation(op, registry, ctx, opts) {
+    let attempt = 0;
+    let lastError;
+    while (attempt <= opts.retries) {
+        try {
+            const nativeId = await execute(op, registry, ctx);
+            return { op, status: 'succeeded', ...(nativeId ? { nativeId } : {}) };
+        }
+        catch (raw) {
+            const err = toProviderError(raw);
+            lastError = err;
+            if (!err.recoverable) {
+                return { op, status: 'failed', error: err };
+            }
+            attempt += 1;
+            if (attempt > opts.retries)
+                break;
+            if (opts.backoffMs > 0)
+                await sleep(opts.backoffMs * attempt);
+        }
+    }
+    return { op, status: 'failed', error: lastError ?? unknownError() };
+}
+async function execute(op, registry, ctx) {
+    switch (op.kind) {
+        case 'create': {
+            const provider = registry.get(op.resourceType);
+            const result = await provider.create(ctx, op.label, op.properties);
+            return result.nativeId;
+        }
+        case 'update': {
+            const provider = registry.get(op.resourceType);
+            const result = await provider.update(ctx, op.nativeId, op.prior, op.properties);
+            if (result.kind === 'noop')
+                return op.nativeId;
+            return result.nativeId;
+        }
+        case 'delete': {
+            const provider = registry.get(op.resourceType);
+            await provider.delete(ctx, op.nativeId);
+            return op.nativeId;
+        }
+        case 'noop':
+            return undefined;
+    }
+}
+function toProviderError(raw) {
+    if (raw && typeof raw === 'object' && 'code' in raw && 'recoverable' in raw) {
+        return raw;
+    }
+    return {
+        code: 'ServiceInternalError',
+        recoverable: true,
+        message: raw instanceof Error ? raw.message : String(raw),
+        cause: raw,
+    };
+}
+function unknownError() {
+    return {
+        code: 'ServiceInternalError',
+        recoverable: false,
+        message: 'unknown error after retries',
+    };
+}
+function summarize(results) {
+    let succeeded = 0;
+    let failed = 0;
+    let skipped = 0;
+    for (const r of results) {
+        if (r.status === 'succeeded')
+            succeeded += 1;
+        else if (r.status === 'failed')
+            failed += 1;
+        else
+            skipped += 1;
+    }
+    return { results, succeeded, failed, skipped };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=apply.js.map