@mizchi/k1c 0.1.0

package/dist/reconciler/fake-provider.d.ts

@@ -0,0 +1,48 @@
+import type { ZodSchema } from 'zod';
+import type { CloudflareResourceProvider, CreateResult, DeleteResult, ListedResource, ProviderContext, ProviderError, StatusResult, UpdateResult } from '../providers/types.ts';
+import { NotFound } from '../providers/types.ts';
+export type FakeEvent = {
+    readonly op: 'create';
+    readonly nativeId: string;
+    readonly label: string;
+    readonly properties: unknown;
+} | {
+    readonly op: 'update';
+    readonly nativeId: string;
+    readonly properties: unknown;
+} | {
+    readonly op: 'delete';
+    readonly nativeId: string;
+} | {
+    readonly op: 'read';
+    readonly nativeId: string;
+} | {
+    readonly op: 'list';
+};
+export interface FakeFailure {
+    readonly op: 'create' | 'update' | 'delete' | 'read';
+    remaining: number;
+    readonly error: ProviderError;
+}
+export declare class FakeProvider<P> implements CloudflareResourceProvider<P> {
+    #private;
+    readonly resourceType: string;
+    readonly schema: ZodSchema<P>;
+    readonly state: Map<string, {
+        label: string;
+        properties: P;
+    }>;
+    readonly events: FakeEvent[];
+    readonly failures: FakeFailure[];
+    constructor(resourceType: string, schema: ZodSchema<P>);
+    seed(nativeId: string, label: string, properties: P): void;
+    injectFailure(failure: FakeFailure): void;
+    list(_ctx: ProviderContext): AsyncIterable<ListedResource>;
+    read(_ctx: ProviderContext, nativeId: string): Promise<P | NotFound>;
+    create(_ctx: ProviderContext, label: string, desired: P): Promise<CreateResult>;
+    update(_ctx: ProviderContext, nativeId: string, _prior: P, desired: P): Promise<UpdateResult>;
+    delete(_ctx: ProviderContext, nativeId: string): Promise<DeleteResult>;
+    status(_ctx: ProviderContext, _nativeId: string, _opId: string): Promise<StatusResult>;
+}
+export declare function makeFakeContext(): ProviderContext;
+//# sourceMappingURL=fake-provider.d.ts.map

package/dist/reconciler/fake-provider.js

@@ -0,0 +1,83 @@
+import { NotFound } from "../providers/types.js";
+export class FakeProvider {
+    resourceType;
+    schema;
+    state = new Map();
+    events = [];
+    failures = [];
+    #idCounter = 0;
+    constructor(resourceType, schema) {
+        this.resourceType = resourceType;
+        this.schema = schema;
+    }
+    seed(nativeId, label, properties) {
+        this.state.set(nativeId, { label, properties });
+    }
+    injectFailure(failure) {
+        this.failures.push(failure);
+    }
+    #consumeFailure(op) {
+        const f = this.failures.find((x) => x.op === op && x.remaining > 0);
+        if (!f)
+            return undefined;
+        f.remaining -= 1;
+        return f.error;
+    }
+    async *list(_ctx) {
+        this.events.push({ op: 'list' });
+        for (const [nativeId, { label }] of this.state) {
+            yield { nativeId, label };
+        }
+    }
+    async read(_ctx, nativeId) {
+        this.events.push({ op: 'read', nativeId });
+        const err = this.#consumeFailure('read');
+        if (err)
+            throw err;
+        const entry = this.state.get(nativeId);
+        if (!entry)
+            return NotFound;
+        return entry.properties;
+    }
+    async create(_ctx, label, desired) {
+        const err = this.#consumeFailure('create');
+        if (err)
+            throw err;
+        const nativeId = `native-${this.resourceType}-${++this.#idCounter}`;
+        this.state.set(nativeId, { label, properties: desired });
+        this.events.push({ op: 'create', nativeId, label, properties: desired });
+        return { kind: 'sync', nativeId, properties: desired };
+    }
+    async update(_ctx, nativeId, _prior, desired) {
+        const err = this.#consumeFailure('update');
+        if (err)
+            throw err;
+        const entry = this.state.get(nativeId);
+        const label = entry ? entry.label : 'unknown';
+        this.state.set(nativeId, { label, properties: desired });
+        this.events.push({ op: 'update', nativeId, properties: desired });
+        return { kind: 'sync', nativeId, properties: desired };
+    }
+    async delete(_ctx, nativeId) {
+        const err = this.#consumeFailure('delete');
+        if (err)
+            throw err;
+        this.state.delete(nativeId);
+        this.events.push({ op: 'delete', nativeId });
+        return { kind: 'sync' };
+    }
+    async status(_ctx, _nativeId, _opId) {
+        return { kind: 'success', properties: null };
+    }
+}
+export function makeFakeContext() {
+    return {
+        cloudflare: {},
+        accountId: 'test-account',
+        namespace: 'default',
+        managedByLabel: 'k1c.io/managed-by=k1c',
+        signal: new AbortController().signal,
+        readFile: async (path) => new TextEncoder().encode(`// stub for ${path}`),
+    };
+}
+//# sourceMappingURL=fake-provider.js.map

package/dist/reconciler/plan.d.ts

@@ -0,0 +1,6 @@
+import type { ProviderContext } from '../providers/types.ts';
+import type { ProviderRegistry } from '../providers/registry.ts';
+import type { DesiredResource, Plan } from './types.ts';
+export declare function plan(desired: ReadonlyArray<DesiredResource>, registry: ProviderRegistry, ctx: ProviderContext): Promise<Plan>;
+export declare function propertiesEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=plan.d.ts.map

package/dist/reconciler/plan.js

@@ -0,0 +1,124 @@
+import { NotFound } from "../providers/types.js";
+import { namespaceFromLabel } from "./types.js";
+import { refKey } from "../manifest/types.js";
+import { topoSort } from "./topo.js";
+export async function plan(desired, registry, ctx) {
+    const desiredNamespaces = new Set();
+    const desiredByType = new Map();
+    for (const d of desired) {
+        desiredNamespaces.add(d.ref.namespace);
+        const arr = desiredByType.get(d.resourceType) ?? [];
+        arr.push(d);
+        desiredByType.set(d.resourceType, arr);
+    }
+    const operations = [];
+    for (const resourceType of registry.types()) {
+        const provider = registry.get(resourceType);
+        const desiredOfType = desiredByType.get(resourceType) ?? [];
+        const desiredByLabel = new Map();
+        for (const d of desiredOfType)
+            desiredByLabel.set(d.label, d);
+        const actualByLabel = new Map();
+        for await (const item of provider.list(ctx)) {
+            actualByLabel.set(item.label, item);
+        }
+        for (const d of desiredOfType) {
+            const actual = actualByLabel.get(d.label);
+            if (!actual) {
+                operations.push({
+                    kind: 'create',
+                    resourceType,
+                    ref: d.ref,
+                    label: d.label,
+                    properties: d.properties,
+                });
+                continue;
+            }
+            const prior = await provider.read(ctx, actual.nativeId);
+            if (prior === NotFound) {
+                operations.push({
+                    kind: 'create',
+                    resourceType,
+                    ref: d.ref,
+                    label: d.label,
+                    properties: d.properties,
+                });
+                continue;
+            }
+            if (propertiesEqual(prior, d.properties)) {
+                operations.push({
+                    kind: 'noop',
+                    resourceType,
+                    ref: d.ref,
+                    label: d.label,
+                });
+            }
+            else {
+                operations.push({
+                    kind: 'update',
+                    resourceType,
+                    ref: d.ref,
+                    label: d.label,
+                    nativeId: actual.nativeId,
+                    prior,
+                    properties: d.properties,
+                });
+            }
+        }
+        for (const [label, actual] of actualByLabel) {
+            if (desiredByLabel.has(label))
+                continue;
+            if (!desiredNamespaces.has(namespaceFromLabel(label)))
+                continue;
+            operations.push({
+                kind: 'delete',
+                resourceType,
+                nativeId: actual.nativeId,
+                label,
+            });
+        }
+    }
+    return { operations: orderByDependencies(operations, desired) };
+}
+function orderByDependencies(operations, desired) {
+    const depsByRef = new Map();
+    for (const d of desired) {
+        depsByRef.set(refKey(d.ref), (d.dependsOn ?? []).map(refKey));
+    }
+    const mutating = [];
+    const noops = [];
+    const deletes = [];
+    for (const op of operations) {
+        if (op.kind === 'create' || op.kind === 'update')
+            mutating.push(op);
+        else if (op.kind === 'noop')
+            noops.push(op);
+        else
+            deletes.push(op);
+    }
+    const nodes = mutating.map((op) => {
+        const id = refKey(op.ref);
+        return { id, op, dependsOn: depsByRef.get(id) ?? [] };
+    });
+    const sortedMutating = topoSort(nodes).map((n) => n.op);
+    noops.sort((a, b) => a.label.localeCompare(b.label));
+    deletes.sort((a, b) => a.label.localeCompare(b.label));
+    return [...sortedMutating, ...noops, ...deletes];
+}
+export function propertiesEqual(a, b) {
+    return canonicalize(a) === canonicalize(b);
+}
+function canonicalize(value) {
+    return JSON.stringify(value, replacer);
+}
+function replacer(_key, value) {
+    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+        const sorted = {};
+        const keys = Object.keys(value).sort();
+        for (const k of keys)
+            sorted[k] = value[k];
+        return sorted;
+    }
+    return value;
+}
+//# sourceMappingURL=plan.js.map

package/dist/reconciler/topo.d.ts

@@ -0,0 +1,10 @@
+export interface TopoNode {
+    readonly id: string;
+    readonly dependsOn?: ReadonlyArray<string>;
+}
+export declare class CycleError extends Error {
+    readonly cycle: ReadonlyArray<string>;
+    constructor(cycle: ReadonlyArray<string>);
+}
+export declare function topoSort<T extends TopoNode>(nodes: ReadonlyArray<T>): T[];
+//# sourceMappingURL=topo.d.ts.map

package/dist/reconciler/topo.js

@@ -0,0 +1,53 @@
+export class CycleError extends Error {
+    cycle;
+    constructor(cycle) {
+        super(`dependency cycle: ${[...cycle].sort().join(', ')}`);
+        this.name = 'CycleError';
+        this.cycle = cycle;
+    }
+}
+export function topoSort(nodes) {
+    const byId = new Map();
+    for (const node of nodes)
+        byId.set(node.id, node);
+    const inDegree = new Map();
+    const successors = new Map();
+    for (const node of nodes) {
+        inDegree.set(node.id, 0);
+        successors.set(node.id, []);
+    }
+    for (const node of nodes) {
+        for (const dep of node.dependsOn ?? []) {
+            if (!byId.has(dep))
+                continue;
+            inDegree.set(node.id, (inDegree.get(node.id) ?? 0) + 1);
+            successors.get(dep).push(node.id);
+        }
+    }
+    const ready = [];
+    for (const [id, deg] of inDegree) {
+        if (deg === 0)
+            ready.push(id);
+    }
+    ready.sort();
+    const result = [];
+    while (ready.length > 0) {
+        const id = ready.shift();
+        result.push(byId.get(id));
+        const succs = [...(successors.get(id) ?? [])].sort();
+        for (const s of succs) {
+            const newDeg = (inDegree.get(s) ?? 0) - 1;
+            inDegree.set(s, newDeg);
+            if (newDeg === 0)
+                ready.push(s);
+        }
+        ready.sort();
+    }
+    if (result.length < nodes.length) {
+        const resolved = new Set(result.map((n) => n.id));
+        const remaining = nodes.filter((n) => !resolved.has(n.id)).map((n) => n.id);
+        throw new CycleError(remaining);
+    }
+    return result;
+}
+//# sourceMappingURL=topo.js.map

package/dist/reconciler/types.d.ts

@@ -0,0 +1,54 @@
+import type { ResourceRef } from '../manifest/types.ts';
+import type { ProviderError } from '../providers/types.ts';
+export interface DesiredResource<P = unknown> {
+    readonly resourceType: string;
+    readonly ref: ResourceRef;
+    readonly label: string;
+    readonly properties: P;
+    readonly dependsOn?: ReadonlyArray<ResourceRef>;
+}
+export type Operation = {
+    readonly kind: 'create';
+    readonly resourceType: string;
+    readonly ref: ResourceRef;
+    readonly label: string;
+    readonly properties: unknown;
+} | {
+    readonly kind: 'update';
+    readonly resourceType: string;
+    readonly ref: ResourceRef;
+    readonly label: string;
+    readonly nativeId: string;
+    readonly prior: unknown;
+    readonly properties: unknown;
+} | {
+    readonly kind: 'delete';
+    readonly resourceType: string;
+    readonly nativeId: string;
+    readonly label: string;
+} | {
+    readonly kind: 'noop';
+    readonly resourceType: string;
+    readonly ref: ResourceRef;
+    readonly label: string;
+};
+export type OperationKind = Operation['kind'];
+export interface Plan {
+    readonly operations: ReadonlyArray<Operation>;
+}
+export type OperationStatus = 'succeeded' | 'skipped' | 'failed';
+export interface OperationResult {
+    readonly op: Operation;
+    readonly status: OperationStatus;
+    readonly nativeId?: string;
+    readonly error?: ProviderError;
+}
+export interface ApplyReport {
+    readonly results: ReadonlyArray<OperationResult>;
+    readonly succeeded: number;
+    readonly skipped: number;
+    readonly failed: number;
+}
+export declare function labelOf(ref: ResourceRef): string;
+export declare function namespaceFromLabel(label: string): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/reconciler/types.js

@@ -0,0 +1,8 @@
+export function labelOf(ref) {
+    return `${ref.namespace}/${ref.name}`;
+}
+export function namespaceFromLabel(label) {
+    const idx = label.indexOf('/');
+    return idx === -1 ? 'default' : label.slice(0, idx);
+}
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@mizchi/k1c",
+  "version": "0.1.0",
+  "description": "Experimental kubectl-style apply tool for Cloudflare",
+  "keywords": [
+    "cloudflare",
+    "workers",
+    "iac",
+    "kubectl",
+    "kubernetes",
+    "manifest"
+  ],
+  "homepage": "https://github.com/mizchi/k1c",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mizchi/k1c.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mizchi/k1c/issues"
+  },
+  "license": "MIT",
+  "author": "mizchi",
+  "type": "module",
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "pnpm@10.0.0",
+  "bin": {
+    "k1c": "./dist/cli/main.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "secretlint": "secretlint --secretlintignore .secretlintignore '**/*'",
+    "k1c": "node --experimental-strip-types --disable-warning=ExperimentalWarning src/cli/main.ts",
+    "prepublishOnly": "pnpm typecheck && pnpm test && pnpm build"
+  },
+  "dependencies": {
+    "cloudflare": "^4.0.0",
+    "yaml": "^2.6.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@secretlint/secretlint-rule-preset-recommend": "^13.0.0",
+    "@types/node": "^22.10.0",
+    "secretlint": "^13.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  }
+}