@mizchi/k1c 0.1.0

package/dist/providers/hyperdrive.js

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { NotFound } from "./types.js";
+import { toProviderError } from "./errors.js";
+export const hyperdriveSchema = z.object({
+    name: z.string(),
+    origin: z.object({
+        scheme: z.enum(['postgres', 'postgresql', 'mysql']),
+        host: z.string(),
+        port: z.number().int().positive(),
+        database: z.string(),
+        user: z.string(),
+        password: z.string(),
+    }),
+    caching: z
+        .object({
+        disabled: z.boolean().optional(),
+        maxAge: z.number().int().nonnegative().optional(),
+        staleWhileRevalidate: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+    originConnectionLimit: z.number().int().positive().optional(),
+});
+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)}`;
+}
+function buildBody(props) {
+    return {
+        name: props.name,
+        origin: {
+            scheme: props.origin.scheme,
+            host: props.origin.host,
+            port: props.origin.port,
+            database: props.origin.database,
+            user: props.origin.user,
+            password: props.origin.password,
+        },
+        ...(props.caching !== undefined
+            ? {
+                caching: {
+                    ...(props.caching.disabled !== undefined ? { disabled: props.caching.disabled } : {}),
+                    ...(props.caching.maxAge !== undefined ? { max_age: props.caching.maxAge } : {}),
+                    ...(props.caching.staleWhileRevalidate !== undefined
+                        ? { stale_while_revalidate: props.caching.staleWhileRevalidate }
+                        : {}),
+                },
+            }
+            : {}),
+        ...(props.originConnectionLimit !== undefined
+            ? { origin_connection_limit: props.originConnectionLimit }
+            : {}),
+    };
+}
+export const hyperdriveProvider = {
+    resourceType: 'Hyperdrive',
+    schema: hyperdriveSchema,
+    async *list(ctx) {
+        let iter;
+        try {
+            iter = ctx.cloudflare.hyperdrive.configs.list({ account_id: ctx.accountId });
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+        try {
+            for await (const cfg of iter) {
+                const cfgName = cfg.name;
+                const cfgId = cfg.id;
+                if (!cfgName || !cfgId)
+                    continue;
+                const label = parseLabel(cfgName);
+                if (label === null)
+                    continue;
+                yield { nativeId: cfgId, label };
+            }
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async read(ctx, nativeId) {
+        try {
+            const cfg = await ctx.cloudflare.hyperdrive.configs.get(nativeId, {
+                account_id: ctx.accountId,
+            });
+            const c = cfg;
+            if (!c.name || !c.origin?.scheme || !c.origin?.host || c.origin?.port === undefined) {
+                return NotFound;
+            }
+            return {
+                name: c.name,
+                origin: {
+                    scheme: c.origin.scheme,
+                    host: c.origin.host,
+                    port: c.origin.port,
+                    database: c.origin.database ?? '',
+                    user: c.origin.user ?? '',
+                    // Cloudflare never returns the password; using a sentinel makes diffs honest:
+                    // the caller's desired side has a real password, so propertiesEqual will
+                    // disagree, and update() runs to re-upload the correct password every apply.
+                    password: '<write-only>',
+                },
+                ...(c.caching !== undefined
+                    ? {
+                        caching: {
+                            ...(c.caching.disabled !== undefined ? { disabled: c.caching.disabled } : {}),
+                            ...(c.caching.max_age !== undefined ? { maxAge: c.caching.max_age } : {}),
+                            ...(c.caching.stale_while_revalidate !== undefined
+                                ? { staleWhileRevalidate: c.caching.stale_while_revalidate }
+                                : {}),
+                        },
+                    }
+                    : {}),
+                ...(c.origin_connection_limit !== undefined
+                    ? { originConnectionLimit: c.origin_connection_limit }
+                    : {}),
+            };
+        }
+        catch (raw) {
+            const err = toProviderError(raw);
+            if (err.code === 'NotFound')
+                return NotFound;
+            throw err;
+        }
+    },
+    async create(ctx, _label, desired) {
+        try {
+            const cfg = await ctx.cloudflare.hyperdrive.configs.create({
+                account_id: ctx.accountId,
+                ...buildBody(desired),
+            });
+            const id = cfg.id ?? desired.name;
+            return { kind: 'sync', nativeId: id, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async update(ctx, nativeId, _prior, desired) {
+        try {
+            const cfg = await ctx.cloudflare.hyperdrive.configs.update(nativeId, {
+                account_id: ctx.accountId,
+                ...buildBody(desired),
+            });
+            const id = cfg.id ?? nativeId;
+            return { kind: 'sync', nativeId: id, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async delete(ctx, nativeId) {
+        try {
+            await ctx.cloudflare.hyperdrive.configs.delete(nativeId, { account_id: ctx.accountId });
+            return { kind: 'sync' };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+};
+//# sourceMappingURL=hyperdrive.js.map

package/dist/providers/index.d.ts

@@ -0,0 +1,6 @@
+import { ProviderRegistry } from './registry.ts';
+export declare function createDefaultRegistry(): ProviderRegistry;
+export { ProviderRegistry } from './registry.ts';
+export type { CloudflareResourceProvider, ProviderContext, CreateResult, UpdateResult, DeleteResult, StatusResult, ProviderError, ProviderErrorCode, ListedResource, } from './types.ts';
+export { NotFound, isRecoverable, RECOVERABLE_CODES } from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -0,0 +1,36 @@
+import { ProviderRegistry } from "./registry.js";
+import { workerProvider } from "./worker.js";
+import { r2BucketProvider } from "./r2-bucket.js";
+import { kvNamespaceProvider } from "./kv-namespace.js";
+import { configMapProvider } from "./configmap.js";
+import { secretProvider } from "./secret.js";
+import { dispatchNamespaceProvider } from "./dispatch-namespace.js";
+import { customDomainProvider } from "./custom-domain.js";
+import { hyperdriveProvider } from "./hyperdrive.js";
+import { d1DatabaseProvider } from "./d1-database.js";
+import { queueProvider } from "./queue.js";
+import { vectorizeProvider } from "./vectorize.js";
+import { dnsRecordProvider } from "./dns-record.js";
+import { workflowProvider } from "./workflow.js";
+import { logpushJobProvider } from "./logpush-job.js";
+export function createDefaultRegistry() {
+    const r = new ProviderRegistry();
+    r.register(workerProvider);
+    r.register(r2BucketProvider);
+    r.register(kvNamespaceProvider);
+    r.register(configMapProvider);
+    r.register(secretProvider);
+    r.register(dispatchNamespaceProvider);
+    r.register(customDomainProvider);
+    r.register(hyperdriveProvider);
+    r.register(d1DatabaseProvider);
+    r.register(queueProvider);
+    r.register(vectorizeProvider);
+    r.register(dnsRecordProvider);
+    r.register(workflowProvider);
+    r.register(logpushJobProvider);
+    return r;
+}
+export { ProviderRegistry } from "./registry.js";
+export { NotFound, isRecoverable, RECOVERABLE_CODES } from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/providers/kv-namespace.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { CloudflareResourceProvider } from './types.ts';
+export interface KVNamespaceProperties {
+    readonly title: string;
+}
+export declare const kvNamespaceSchema: z.ZodType<KVNamespaceProperties>;
+export declare const kvNamespaceProvider: CloudflareResourceProvider<KVNamespaceProperties>;
+//# sourceMappingURL=kv-namespace.d.ts.map

package/dist/providers/kv-namespace.js

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { NotFound } from "./types.js";
+import { toProviderError } from "./errors.js";
+export const kvNamespaceSchema = z.object({
+    title: z.string(),
+});
+const TITLE_PREFIX = 'k1c/';
+function parseLabel(title) {
+    if (!title.startsWith(TITLE_PREFIX))
+        return null;
+    const rest = title.slice(TITLE_PREFIX.length);
+    const slash = rest.indexOf('/');
+    if (slash <= 0 || slash === rest.length - 1)
+        return null;
+    const namespace = rest.slice(0, slash);
+    const name = rest.slice(slash + 1);
+    return `${namespace}/${name}`;
+}
+export const kvNamespaceProvider = {
+    resourceType: 'KVNamespace',
+    schema: kvNamespaceSchema,
+    async *list(ctx) {
+        let iter;
+        try {
+            iter = ctx.cloudflare.kv.namespaces.list({ account_id: ctx.accountId });
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+        try {
+            for await (const ns of iter) {
+                const label = parseLabel(ns.title);
+                if (label === null)
+                    continue;
+                yield { nativeId: ns.id, label };
+            }
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async read(ctx, nativeId) {
+        try {
+            const ns = await ctx.cloudflare.kv.namespaces.get(nativeId, { account_id: ctx.accountId });
+            return { title: ns.title };
+        }
+        catch (raw) {
+            const err = toProviderError(raw);
+            if (err.code === 'NotFound')
+                return NotFound;
+            throw err;
+        }
+    },
+    async create(ctx, _label, desired) {
+        try {
+            const ns = await ctx.cloudflare.kv.namespaces.create({
+                account_id: ctx.accountId,
+                title: desired.title,
+            });
+            return { kind: 'sync', nativeId: ns.id, properties: { title: ns.title } };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async update(ctx, nativeId, prior, desired) {
+        if (prior.title === desired.title)
+            return { kind: 'noop' };
+        try {
+            const ns = await ctx.cloudflare.kv.namespaces.update(nativeId, {
+                account_id: ctx.accountId,
+                title: desired.title,
+            });
+            return { kind: 'sync', nativeId: ns.id, properties: { title: ns.title } };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async delete(ctx, nativeId) {
+        try {
+            await ctx.cloudflare.kv.namespaces.delete(nativeId, { account_id: ctx.accountId });
+            return { kind: 'sync' };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+};
+//# sourceMappingURL=kv-namespace.js.map

package/dist/providers/logpush-job.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { CloudflareResourceProvider } from './types.ts';
+export interface LogpushJobProperties {
+    readonly jobName: string;
+    readonly scope: {
+        readonly zoneId: string;
+    } | {
+        readonly accountId: string;
+    };
+    readonly dataset: string;
+    readonly destinationConf: string;
+    readonly enabled?: boolean;
+    readonly filter?: string;
+}
+export declare const logpushJobPropsSchema: z.ZodType<LogpushJobProperties>;
+export declare const logpushJobProvider: CloudflareResourceProvider<LogpushJobProperties>;
+//# sourceMappingURL=logpush-job.d.ts.map

package/dist/providers/logpush-job.js

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { NotFound } from "./types.js";
+import { toProviderError } from "./errors.js";
+export const logpushJobPropsSchema = z.object({
+    jobName: z.string(),
+    scope: z.union([
+        z.object({ zoneId: z.string() }),
+        z.object({ accountId: z.string() }),
+    ]),
+    dataset: z.string(),
+    destinationConf: z.string(),
+    enabled: z.boolean().optional(),
+    filter: z.string().optional(),
+});
+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)}`;
+}
+function scopeParams(scope) {
+    return 'zoneId' in scope
+        ? { zone_id: scope.zoneId }
+        : { account_id: scope.accountId };
+}
+export const logpushJobProvider = {
+    resourceType: 'LogpushJob',
+    schema: logpushJobPropsSchema,
+    async *list(ctx) {
+        // List by zone (if ctx has a zoneId) and / or by account.
+        const seen = new Set();
+        const params = [
+            { account_id: ctx.accountId },
+        ];
+        if (ctx.zoneId !== undefined)
+            params.push({ zone_id: ctx.zoneId });
+        for (const p of params) {
+            let iter;
+            try {
+                iter = ctx.cloudflare.logpush.jobs.list(p);
+            }
+            catch (raw) {
+                throw toProviderError(raw);
+            }
+            try {
+                for await (const job of iter) {
+                    if (job === null)
+                        continue;
+                    const j = job;
+                    if (j.id === undefined || seen.has(j.id))
+                        continue;
+                    seen.add(j.id);
+                    if (!j.name)
+                        continue;
+                    const label = parseLabel(j.name);
+                    if (label === null)
+                        continue;
+                    yield { nativeId: String(j.id), label };
+                }
+            }
+            catch (raw) {
+                throw toProviderError(raw);
+            }
+        }
+    },
+    async read(ctx, nativeId) {
+        const id = Number(nativeId);
+        if (Number.isNaN(id))
+            return NotFound;
+        // Try account scope first; fall back to zone scope if ctx has one. Logpush jobs
+        // are addressable by id under the scope they were created in, so we probe both.
+        const scopes = [
+            { account_id: ctx.accountId },
+        ];
+        if (ctx.zoneId !== undefined)
+            scopes.push({ zone_id: ctx.zoneId });
+        for (const scope of scopes) {
+            try {
+                const job = await ctx.cloudflare.logpush.jobs.get(id, scope);
+                if (job === null)
+                    continue;
+                const j = job;
+                if (!j.name || !j.dataset || !j.destination_conf)
+                    continue;
+                const propsScope = scope.zone_id !== undefined
+                    ? { zoneId: scope.zone_id }
+                    : { accountId: scope.account_id };
+                return {
+                    jobName: j.name,
+                    scope: propsScope,
+                    dataset: j.dataset,
+                    destinationConf: j.destination_conf,
+                    ...(j.enabled !== undefined ? { enabled: j.enabled } : {}),
+                    ...(j.filter !== undefined ? { filter: j.filter } : {}),
+                };
+            }
+            catch (raw) {
+                const err = toProviderError(raw);
+                if (err.code === 'NotFound')
+                    continue;
+                throw err;
+            }
+        }
+        return NotFound;
+    },
+    async create(ctx, _label, desired) {
+        try {
+            const job = await ctx.cloudflare.logpush.jobs.create({
+                ...scopeParams(desired.scope),
+                name: desired.jobName,
+                dataset: desired.dataset,
+                destination_conf: desired.destinationConf,
+                ...(desired.enabled !== undefined ? { enabled: desired.enabled } : {}),
+                ...(desired.filter !== undefined ? { filter: desired.filter } : {}),
+            });
+            const id = job?.id;
+            if (id === undefined)
+                throw new Error('logpush.jobs.create returned no id');
+            return { kind: 'sync', nativeId: String(id), properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async update(ctx, nativeId, _prior, desired) {
+        const id = Number(nativeId);
+        if (Number.isNaN(id)) {
+            throw {
+                code: 'InvalidRequest',
+                recoverable: false,
+                message: `logpushJob.update: nativeId "${nativeId}" is not a numeric job id`,
+            };
+        }
+        try {
+            await ctx.cloudflare.logpush.jobs.update(id, {
+                ...scopeParams(desired.scope),
+                destination_conf: desired.destinationConf,
+                ...(desired.enabled !== undefined ? { enabled: desired.enabled } : {}),
+                ...(desired.filter !== undefined ? { filter: desired.filter } : {}),
+            });
+            return { kind: 'sync', nativeId, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async delete(ctx, nativeId) {
+        const id = Number(nativeId);
+        if (Number.isNaN(id)) {
+            throw {
+                code: 'InvalidRequest',
+                recoverable: false,
+                message: `logpushJob.delete: nativeId "${nativeId}" is not a numeric job id`,
+            };
+        }
+        const scopes = [
+            { account_id: ctx.accountId },
+        ];
+        if (ctx.zoneId !== undefined)
+            scopes.push({ zone_id: ctx.zoneId });
+        let lastErr;
+        for (const scope of scopes) {
+            try {
+                await ctx.cloudflare.logpush.jobs.delete(id, scope);
+                return { kind: 'sync' };
+            }
+            catch (raw) {
+                const err = toProviderError(raw);
+                if (err.code !== 'NotFound')
+                    throw err;
+                lastErr = raw;
+            }
+        }
+        throw toProviderError(lastErr);
+    },
+};
+//# sourceMappingURL=logpush-job.js.map

package/dist/providers/queue.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import type { CloudflareResourceProvider } from './types.ts';
+export interface QueueProperties {
+    readonly queueName: string;
+    /** When set, k1c will register the named Worker as a consumer of this queue. */
+    readonly consumerWorkerName?: string;
+}
+export declare const queuePropsSchema: z.ZodType<QueueProperties>;
+export declare const queueProvider: CloudflareResourceProvider<QueueProperties>;
+//# sourceMappingURL=queue.d.ts.map

package/dist/providers/queue.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { NotFound } from "./types.js";
+import { toProviderError } from "./errors.js";
+export const queuePropsSchema = z.object({
+    queueName: z.string(),
+    consumerWorkerName: z.string().optional(),
+});
+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 queueProvider = {
+    resourceType: 'Queue',
+    schema: queuePropsSchema,
+    async *list(ctx) {
+        let iter;
+        try {
+            iter = ctx.cloudflare.queues.list({ account_id: ctx.accountId });
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+        try {
+            for await (const q of iter) {
+                const qName = q.queue_name;
+                const qId = q.queue_id;
+                if (!qName || !qId)
+                    continue;
+                const label = parseLabel(qName);
+                if (label === null)
+                    continue;
+                yield { nativeId: qId, label };
+            }
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async read(ctx, nativeId) {
+        try {
+            const q = await ctx.cloudflare.queues.get(nativeId, { account_id: ctx.accountId });
+            const obj = q;
+            if (!obj.queue_name)
+                return NotFound;
+            // Pick the first Worker-style consumer if any. Multi-consumer queues are out of
+            // scope for v0.2; the reconciler will overwrite with the manifest's intent.
+            const consumer = (obj.consumers ?? []).find((c) => typeof (c.script ?? c.service) === 'string');
+            const consumerWorkerName = consumer?.script ?? consumer?.service;
+            return {
+                queueName: obj.queue_name,
+                ...(consumerWorkerName !== undefined ? { consumerWorkerName } : {}),
+            };
+        }
+        catch (raw) {
+            const err = toProviderError(raw);
+            if (err.code === 'NotFound')
+                return NotFound;
+            throw err;
+        }
+    },
+    async create(ctx, _label, desired) {
+        try {
+            const q = await ctx.cloudflare.queues.create({
+                account_id: ctx.accountId,
+                queue_name: desired.queueName,
+            });
+            const id = q.queue_id ?? desired.queueName;
+            if (desired.consumerWorkerName !== undefined) {
+                await registerConsumer(ctx, id, desired.consumerWorkerName);
+            }
+            return { kind: 'sync', nativeId: id, properties: desired };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+    async update(ctx, nativeId, prior, desired) {
+        if (prior.queueName !== desired.queueName) {
+            throw {
+                code: 'NotUpdatable',
+                recoverable: false,
+                suggest: 'recreate',
+                message: 'Queue name is immutable; recreate to change.',
+            };
+        }
+        if (prior.consumerWorkerName !== desired.consumerWorkerName) {
+            try {
+                // Cloudflare's queue consumer API supports multiple consumers; we treat the
+                // manifest as authoritative and re-register. A more careful diff would
+                // delete-then-create, but for v0.2 the upsert pattern is good enough.
+                if (desired.consumerWorkerName !== undefined) {
+                    await registerConsumer(ctx, nativeId, desired.consumerWorkerName);
+                }
+            }
+            catch (raw) {
+                throw toProviderError(raw);
+            }
+        }
+        return { kind: 'sync', nativeId, properties: desired };
+    },
+    async delete(ctx, nativeId) {
+        try {
+            await ctx.cloudflare.queues.delete(nativeId, { account_id: ctx.accountId });
+            return { kind: 'sync' };
+        }
+        catch (raw) {
+            throw toProviderError(raw);
+        }
+    },
+};
+async function registerConsumer(ctx, queueId, workerName) {
+    await ctx.cloudflare.queues.consumers.create(queueId, {
+        account_id: ctx.accountId,
+        type: 'worker',
+        script_name: workerName,
+    });
+}
+//# sourceMappingURL=queue.js.map

package/dist/providers/r2-bucket.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { CloudflareResourceProvider } from './types.ts';
+export type R2Location = 'wnam' | 'enam' | 'weur' | 'eeur' | 'apac' | 'oc';
+export interface R2BucketProperties {
+    readonly bucketName: string;
+    readonly location?: R2Location;
+    readonly storageClass?: 'Standard' | 'InfrequentAccess';
+}
+export declare const r2BucketSchema: z.ZodType<R2BucketProperties>;
+export declare const r2BucketProvider: CloudflareResourceProvider<R2BucketProperties>;
+//# sourceMappingURL=r2-bucket.d.ts.map