@mizchi/k1c 0.1.0

package/dist/manifest/schemas.js

@@ -0,0 +1,309 @@
+import { z } from 'zod';
+const objectMetaSchema = z.object({
+    name: z.string().min(1),
+    namespace: z.string().optional(),
+    labels: z.record(z.string()).optional(),
+    annotations: z.record(z.string()).optional(),
+});
+const envVarSourceSchema = z.object({
+    configMapKeyRef: z
+        .object({ name: z.string(), key: z.string() })
+        .optional(),
+    secretKeyRef: z
+        .object({ name: z.string(), key: z.string() })
+        .optional(),
+});
+const envVarSchema = z.object({
+    name: z.string(),
+    value: z.string().optional(),
+    valueFrom: envVarSourceSchema.optional(),
+});
+const volumeMountSchema = z.object({
+    name: z.string(),
+    mountPath: z.string(),
+});
+const volumeSchema = z.object({
+    name: z.string(),
+    r2BucketRef: z.object({ name: z.string() }).optional(),
+    kvNamespaceRef: z.object({ name: z.string() }).optional(),
+    serviceRef: z.object({ name: z.string() }).optional(),
+    hyperdriveRef: z.object({ name: z.string() }).optional(),
+    d1DatabaseRef: z.object({ name: z.string() }).optional(),
+    queueRef: z.object({ name: z.string() }).optional(),
+    vectorizeRef: z.object({ name: z.string() }).optional(),
+    analyticsEngineRef: z.object({ dataset: z.string() }).optional(),
+});
+const containerSchema = z.object({
+    name: z.string(),
+    image: z.string(),
+    env: z.array(envVarSchema).optional(),
+    volumeMounts: z.array(volumeMountSchema).optional(),
+});
+const podSpecSchema = z.object({
+    containers: z.array(containerSchema).min(1),
+    volumes: z.array(volumeSchema).optional(),
+});
+const podTemplateSpecSchema = z.object({
+    metadata: objectMetaSchema.partial({ name: true }).optional(),
+    spec: podSpecSchema,
+});
+const deploymentSpecSchema = z.object({
+    replicas: z.number().int().nonnegative().optional(),
+    selector: z.object({ matchLabels: z.record(z.string()) }),
+    template: podTemplateSpecSchema,
+});
+export const deploymentSchema = z.object({
+    apiVersion: z.literal('apps/v1'),
+    kind: z.literal('Deployment'),
+    metadata: objectMetaSchema,
+    spec: deploymentSpecSchema,
+});
+const statefulSetSpecSchema = z.object({
+    replicas: z.number().int().nonnegative().optional(),
+    serviceName: z.string().optional(),
+    selector: z.object({ matchLabels: z.record(z.string()) }),
+    template: podTemplateSpecSchema,
+});
+export const statefulSetSchema = z.object({
+    apiVersion: z.literal('apps/v1'),
+    kind: z.literal('StatefulSet'),
+    metadata: objectMetaSchema,
+    spec: statefulSetSpecSchema,
+});
+const blueGreenSchema = z.object({
+    autoPromotionEnabled: z.boolean().optional(),
+    scaleDownDelaySeconds: z.number().int().nonnegative().optional(),
+});
+const canaryStepSchema = z.union([
+    z.object({ setWeight: z.number().min(0).max(100) }),
+    z.object({ pause: z.object({ duration: z.string().optional() }) }),
+]);
+const canarySchema = z.object({
+    steps: z.array(canaryStepSchema),
+});
+const rolloutStrategySchema = z.union([
+    z.object({ blueGreen: blueGreenSchema }),
+    z.object({ canary: canarySchema }),
+]);
+const rolloutSpecSchema = z.object({
+    replicas: z.number().int().nonnegative().optional(),
+    selector: z.object({ matchLabels: z.record(z.string()) }),
+    template: podTemplateSpecSchema,
+    strategy: rolloutStrategySchema,
+});
+export const rolloutSchema = z.object({
+    apiVersion: z.literal('argoproj.io/v1alpha1'),
+    kind: z.literal('Rollout'),
+    metadata: objectMetaSchema,
+    spec: rolloutSpecSchema,
+});
+const cronJobSpecSchema = z.object({
+    schedule: z.string().min(1),
+    jobTemplate: z.object({
+        spec: z.object({ template: podTemplateSpecSchema }),
+    }),
+    successfulJobsHistoryLimit: z.number().int().nonnegative().optional(),
+    failedJobsHistoryLimit: z.number().int().nonnegative().optional(),
+    suspend: z.boolean().optional(),
+});
+export const cronJobSchema = z.object({
+    apiVersion: z.literal('batch/v1'),
+    kind: z.literal('CronJob'),
+    metadata: objectMetaSchema,
+    spec: cronJobSpecSchema,
+});
+export const configMapSchema = z.object({
+    apiVersion: z.literal('v1'),
+    kind: z.literal('ConfigMap'),
+    metadata: objectMetaSchema,
+    data: z.record(z.string()).optional(),
+});
+export const secretSchema = z.object({
+    apiVersion: z.literal('v1'),
+    kind: z.literal('Secret'),
+    metadata: objectMetaSchema,
+    type: z.string().optional(),
+    data: z.record(z.string()).optional(),
+    stringData: z.record(z.string()).optional(),
+});
+export const namespaceSchema = z.object({
+    apiVersion: z.literal('v1'),
+    kind: z.literal('Namespace'),
+    metadata: objectMetaSchema,
+});
+export const serviceSchema = z.object({
+    apiVersion: z.literal('v1'),
+    kind: z.literal('Service'),
+    metadata: objectMetaSchema,
+    spec: z.object({
+        type: z.enum(['ClusterIP', 'LoadBalancer']).optional(),
+        selector: z.record(z.string()),
+        ports: z
+            .array(z.object({
+            port: z.number().int().positive(),
+            targetPort: z.number().int().positive().optional(),
+            name: z.string().optional(),
+            protocol: z.enum(['TCP', 'UDP']).optional(),
+        }))
+            .optional(),
+    }),
+});
+export const r2BucketSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('R2Bucket'),
+    metadata: objectMetaSchema,
+    spec: z.object({
+        location: z.enum(['wnam', 'enam', 'weur', 'eeur', 'apac', 'oc']).optional(),
+        storageClass: z.enum(['Standard', 'InfrequentAccess']).optional(),
+    }),
+});
+export const kvNamespaceSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('KVNamespace'),
+    metadata: objectMetaSchema,
+    spec: z.object({
+        title: z.string().optional(),
+    }),
+});
+export const dispatchNamespaceSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('DispatchNamespace'),
+    metadata: objectMetaSchema,
+    spec: z.object({}).strict().optional().default({}),
+});
+export const hyperdriveSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('Hyperdrive'),
+    metadata: objectMetaSchema,
+    spec: z.object({
+        origin: z.object({
+            scheme: z.enum(['postgres', 'postgresql', 'mysql']),
+            host: z.string().min(1),
+            port: z.number().int().positive(),
+            database: z.string().min(1),
+            user: z.string().min(1),
+            passwordSecretRef: z.object({ name: z.string(), key: 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(),
+    }),
+});
+export const d1DatabaseSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('D1Database'),
+    metadata: objectMetaSchema,
+    spec: z
+        .object({
+        primaryLocationHint: z
+            .enum(['wnam', 'enam', 'weur', 'eeur', 'apac', 'oc'])
+            .optional(),
+    })
+        .optional()
+        .default({}),
+});
+export const queueSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('Queue'),
+    metadata: objectMetaSchema,
+    spec: z
+        .object({
+        consumer: z.object({ workerName: z.string() }).optional(),
+    })
+        .optional()
+        .default({}),
+});
+export const vectorizeSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('Vectorize'),
+    metadata: objectMetaSchema,
+    spec: z.object({
+        dimensions: z.number().int().positive(),
+        metric: z.enum(['cosine', 'euclidean', 'dot-product']),
+        description: z.string().optional(),
+    }),
+});
+export const dnsRecordSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('DNSRecord'),
+    metadata: objectMetaSchema,
+    spec: z.object({
+        zoneId: z.string(),
+        type: z.enum(['A', 'AAAA', 'CNAME', 'TXT', 'MX']),
+        name: z.string(),
+        content: z.string(),
+        ttl: z.number().int().nonnegative().optional(),
+        proxied: z.boolean().optional(),
+        priority: z.number().int().nonnegative().optional(),
+    }),
+});
+const jobSpecSchema = z.object({
+    template: podTemplateSpecSchema,
+    backoffLimit: z.number().int().nonnegative().optional(),
+    activeDeadlineSeconds: z.number().int().positive().optional(),
+    completions: z.number().int().positive().optional(),
+    parallelism: z.number().int().positive().optional(),
+});
+export const jobSchema = z.object({
+    apiVersion: z.literal('batch/v1'),
+    kind: z.literal('Job'),
+    metadata: objectMetaSchema,
+    spec: jobSpecSchema,
+});
+export const logpushJobSchema = z.object({
+    apiVersion: z.literal('cloudflare.k1c.io/v1alpha1'),
+    kind: z.literal('LogpushJob'),
+    metadata: objectMetaSchema,
+    spec: z
+        .object({
+        zoneId: z.string().optional(),
+        accountId: z.string().optional(),
+        dataset: z.enum([
+            'http_requests',
+            'workers_trace_events',
+            'firewall_events',
+            'access_requests',
+            'audit_logs',
+            'dns_logs',
+            'spectrum_events',
+            'nel_reports',
+            'gateway_dns',
+            'gateway_http',
+            'gateway_network',
+            'magic_ids_detections',
+            'network_analytics_logs',
+        ]),
+        destinationConf: z.string().min(1),
+        enabled: z.boolean().optional(),
+        filter: z.string().optional(),
+    })
+        .refine((s) => (s.zoneId !== undefined) !== (s.accountId !== undefined), {
+        message: 'LogpushJob.spec must specify exactly one of zoneId / accountId',
+    }),
+});
+export const k1cResourceSchema = z.discriminatedUnion('kind', [
+    deploymentSchema,
+    rolloutSchema,
+    statefulSetSchema,
+    cronJobSchema,
+    jobSchema,
+    configMapSchema,
+    secretSchema,
+    namespaceSchema,
+    serviceSchema,
+    r2BucketSchema,
+    kvNamespaceSchema,
+    dispatchNamespaceSchema,
+    hyperdriveSchema,
+    d1DatabaseSchema,
+    queueSchema,
+    vectorizeSchema,
+    dnsRecordSchema,
+    logpushJobSchema,
+]);
+//# sourceMappingURL=schemas.js.map

package/dist/manifest/types.d.ts

@@ -0,0 +1,246 @@
+export interface ObjectMeta {
+    readonly name: string;
+    readonly namespace?: string;
+    readonly labels?: Readonly<Record<string, string>>;
+    readonly annotations?: Readonly<Record<string, string>>;
+}
+export interface BaseResource<Kind extends string, ApiVersion extends string, Spec> {
+    readonly apiVersion: ApiVersion;
+    readonly kind: Kind;
+    readonly metadata: ObjectMeta;
+    readonly spec: Spec;
+}
+export interface ContainerSpec {
+    readonly name: string;
+    readonly image: string;
+    readonly env?: ReadonlyArray<EnvVar>;
+    readonly volumeMounts?: ReadonlyArray<VolumeMount>;
+}
+export interface EnvVar {
+    readonly name: string;
+    readonly value?: string;
+    readonly valueFrom?: EnvVarSource;
+}
+export interface EnvVarSource {
+    readonly configMapKeyRef?: {
+        readonly name: string;
+        readonly key: string;
+    };
+    readonly secretKeyRef?: {
+        readonly name: string;
+        readonly key: string;
+    };
+}
+export interface VolumeMount {
+    readonly name: string;
+    readonly mountPath: string;
+}
+export interface Volume {
+    readonly name: string;
+    readonly r2BucketRef?: {
+        readonly name: string;
+    };
+    readonly kvNamespaceRef?: {
+        readonly name: string;
+    };
+    readonly serviceRef?: {
+        readonly name: string;
+    };
+    readonly hyperdriveRef?: {
+        readonly name: string;
+    };
+    readonly d1DatabaseRef?: {
+        readonly name: string;
+    };
+    readonly queueRef?: {
+        readonly name: string;
+    };
+    readonly vectorizeRef?: {
+        readonly name: string;
+    };
+    readonly analyticsEngineRef?: {
+        readonly dataset: string;
+    };
+}
+export interface PodTemplateSpec {
+    readonly metadata?: ObjectMeta;
+    readonly spec: PodSpec;
+}
+export interface PodSpec {
+    readonly containers: ReadonlyArray<ContainerSpec>;
+    readonly volumes?: ReadonlyArray<Volume>;
+}
+export interface DeploymentSpec {
+    readonly replicas?: number;
+    readonly selector: {
+        readonly matchLabels: Readonly<Record<string, string>>;
+    };
+    readonly template: PodTemplateSpec;
+}
+export type Deployment = BaseResource<'Deployment', 'apps/v1', DeploymentSpec>;
+export interface StatefulSetSpec {
+    readonly replicas?: number;
+    readonly serviceName?: string;
+    readonly selector: {
+        readonly matchLabels: Readonly<Record<string, string>>;
+    };
+    readonly template: PodTemplateSpec;
+}
+export type StatefulSet = BaseResource<'StatefulSet', 'apps/v1', StatefulSetSpec>;
+export interface BlueGreenStrategy {
+    readonly autoPromotionEnabled?: boolean;
+    readonly scaleDownDelaySeconds?: number;
+}
+export interface CanaryStrategy {
+    readonly steps: ReadonlyArray<CanaryStep>;
+}
+export type CanaryStep = {
+    readonly setWeight: number;
+} | {
+    readonly pause: {
+        readonly duration?: string;
+    };
+};
+export type RolloutStrategy = {
+    readonly blueGreen: BlueGreenStrategy;
+} | {
+    readonly canary: CanaryStrategy;
+};
+export interface RolloutSpec {
+    readonly replicas?: number;
+    readonly selector: {
+        readonly matchLabels: Readonly<Record<string, string>>;
+    };
+    readonly template: PodTemplateSpec;
+    readonly strategy: RolloutStrategy;
+}
+export type Rollout = BaseResource<'Rollout', 'argoproj.io/v1alpha1', RolloutSpec>;
+export interface JobTemplateSpec {
+    readonly spec: {
+        readonly template: PodTemplateSpec;
+    };
+}
+export interface CronJobSpec {
+    readonly schedule: string;
+    readonly jobTemplate: JobTemplateSpec;
+    readonly successfulJobsHistoryLimit?: number;
+    readonly failedJobsHistoryLimit?: number;
+    readonly suspend?: boolean;
+}
+export type CronJob = BaseResource<'CronJob', 'batch/v1', CronJobSpec>;
+export interface ConfigMapResource extends BaseResource<'ConfigMap', 'v1', never> {
+    readonly data?: Readonly<Record<string, string>>;
+}
+export interface SecretResource extends BaseResource<'Secret', 'v1', never> {
+    readonly type?: string;
+    readonly data?: Readonly<Record<string, string>>;
+    readonly stringData?: Readonly<Record<string, string>>;
+}
+export interface NamespaceResource extends BaseResource<'Namespace', 'v1', never> {
+}
+export interface ServicePort {
+    readonly port: number;
+    readonly targetPort?: number;
+    readonly name?: string;
+    readonly protocol?: 'TCP' | 'UDP';
+}
+export interface ServiceSpec {
+    readonly type?: 'ClusterIP' | 'LoadBalancer';
+    readonly selector: Readonly<Record<string, string>>;
+    readonly ports?: ReadonlyArray<ServicePort>;
+}
+export type ServiceResource = BaseResource<'Service', 'v1', ServiceSpec>;
+export interface R2BucketSpec {
+    readonly location?: 'wnam' | 'enam' | 'weur' | 'eeur' | 'apac' | 'oc';
+    readonly storageClass?: 'Standard' | 'InfrequentAccess';
+}
+export type R2Bucket = BaseResource<'R2Bucket', 'cloudflare.k1c.io/v1alpha1', R2BucketSpec>;
+export interface KVNamespaceSpec {
+    readonly title?: string;
+}
+export type KVNamespace = BaseResource<'KVNamespace', 'cloudflare.k1c.io/v1alpha1', KVNamespaceSpec>;
+export interface DispatchNamespaceSpec {
+    readonly _placeholder?: never;
+}
+export type DispatchNamespace = BaseResource<'DispatchNamespace', 'cloudflare.k1c.io/v1alpha1', DispatchNamespaceSpec>;
+export type HyperdriveScheme = 'postgres' | 'postgresql' | 'mysql';
+export interface HyperdriveOrigin {
+    readonly scheme: HyperdriveScheme;
+    readonly host: string;
+    readonly port: number;
+    readonly database: string;
+    readonly user: string;
+    /** The password value is read from the referenced Secret at lower time. */
+    readonly passwordSecretRef: {
+        readonly name: string;
+        readonly key: string;
+    };
+}
+export interface HyperdriveCaching {
+    readonly disabled?: boolean;
+    readonly maxAge?: number;
+    readonly staleWhileRevalidate?: number;
+}
+export interface HyperdriveSpec {
+    readonly origin: HyperdriveOrigin;
+    readonly caching?: HyperdriveCaching;
+    readonly originConnectionLimit?: number;
+}
+export type Hyperdrive = BaseResource<'Hyperdrive', 'cloudflare.k1c.io/v1alpha1', HyperdriveSpec>;
+export interface D1DatabaseSpec {
+    readonly primaryLocationHint?: 'wnam' | 'enam' | 'weur' | 'eeur' | 'apac' | 'oc';
+}
+export type D1Database = BaseResource<'D1Database', 'cloudflare.k1c.io/v1alpha1', D1DatabaseSpec>;
+export interface QueueSpec {
+    /** Optional consumer Worker (referenced by name). The dispatched Worker must exist
+     *  in the same namespace and is wired via `cloudflare.workers.queues.consumers`. */
+    readonly consumer?: {
+        readonly workerName: string;
+    };
+}
+export type Queue = BaseResource<'Queue', 'cloudflare.k1c.io/v1alpha1', QueueSpec>;
+export interface VectorizeSpec {
+    readonly dimensions: number;
+    readonly metric: 'cosine' | 'euclidean' | 'dot-product';
+    readonly description?: string;
+}
+export type Vectorize = BaseResource<'Vectorize', 'cloudflare.k1c.io/v1alpha1', VectorizeSpec>;
+export interface DNSRecordSpec {
+    readonly zoneId: string;
+    readonly type: 'A' | 'AAAA' | 'CNAME' | 'TXT' | 'MX';
+    readonly name: string;
+    readonly content: string;
+    readonly ttl?: number;
+    readonly proxied?: boolean;
+    readonly priority?: number;
+}
+export type DNSRecord = BaseResource<'DNSRecord', 'cloudflare.k1c.io/v1alpha1', DNSRecordSpec>;
+export interface JobSpec {
+    readonly template: PodTemplateSpec;
+    readonly backoffLimit?: number;
+    readonly activeDeadlineSeconds?: number;
+    readonly completions?: number;
+    readonly parallelism?: number;
+}
+export type Job = BaseResource<'Job', 'batch/v1', JobSpec>;
+export interface LogpushJobSpec {
+    /** Either zoneId or accountId is required (mutually exclusive). */
+    readonly zoneId?: string;
+    readonly accountId?: string;
+    readonly dataset: 'http_requests' | 'workers_trace_events' | 'firewall_events' | 'access_requests' | 'audit_logs' | 'dns_logs' | 'spectrum_events' | 'nel_reports' | 'gateway_dns' | 'gateway_http' | 'gateway_network' | 'magic_ids_detections' | 'network_analytics_logs';
+    readonly destinationConf: string;
+    readonly enabled?: boolean;
+    readonly filter?: string;
+}
+export type LogpushJob = BaseResource<'LogpushJob', 'cloudflare.k1c.io/v1alpha1', LogpushJobSpec>;
+export type K1cResource = Deployment | Rollout | StatefulSet | CronJob | Job | ConfigMapResource | SecretResource | NamespaceResource | ServiceResource | R2Bucket | KVNamespace | DispatchNamespace | Hyperdrive | D1Database | Queue | Vectorize | DNSRecord | LogpushJob;
+export type ResourceKind = K1cResource['kind'];
+export interface ResourceRef {
+    readonly apiVersion: string;
+    readonly kind: ResourceKind;
+    readonly namespace: string;
+    readonly name: string;
+}
+export declare function refOf(resource: K1cResource): ResourceRef;
+export declare function refKey(ref: ResourceRef): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/manifest/types.js

@@ -0,0 +1,12 @@
+export function refOf(resource) {
+    return {
+        apiVersion: resource.apiVersion,
+        kind: resource.kind,
+        namespace: resource.metadata.namespace ?? 'default',
+        name: resource.metadata.name,
+    };
+}
+export function refKey(ref) {
+    return `${ref.apiVersion}/${ref.kind}/${ref.namespace}/${ref.name}`;
+}
+//# sourceMappingURL=types.js.map

package/dist/providers/configmap.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { CloudflareResourceProvider } from './types.ts';
+export interface ConfigMapProperties {
+    readonly data: Readonly<Record<string, string>>;
+}
+export declare const configMapSchema: z.ZodType<ConfigMapProperties>;
+export declare const configMapProvider: CloudflareResourceProvider<ConfigMapProperties>;
+//# sourceMappingURL=configmap.d.ts.map

package/dist/providers/configmap.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { NotFound } from "./types.js";
+export const configMapSchema = z.object({
+    data: z.record(z.string()),
+});
+export const configMapProvider = {
+    resourceType: 'ConfigMap',
+    schema: configMapSchema,
+    async *list(_ctx) {
+        // ConfigMap is virtual: its presence is derived from referenced Workers.
+        return;
+    },
+    async read(_ctx, _nativeId) {
+        // Read is satisfied from the resource graph in the reconciler, not from CF API.
+        throw new Error('configMapProvider.read should be served by the reconciler graph, not invoked directly');
+    },
+    async create(_ctx, _label, _desired) {
+        // No-op: writing the values happens during Worker create.
+        return { kind: 'sync', nativeId: _label, properties: _desired };
+    },
+    async update(_ctx, _nativeId, _prior, _desired) {
+        // Update is realized by re-applying referenced Workers; the Worker provider picks up new vars.
+        return { kind: 'noop' };
+    },
+    async delete(_ctx, _nativeId) {
+        return { kind: 'sync' };
+    },
+};
+//# sourceMappingURL=configmap.js.map

package/dist/providers/custom-domain.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { CloudflareResourceProvider } from './types.ts';
+export interface CustomDomainProperties {
+    readonly hostname: string;
+    readonly service: string;
+    readonly zoneId: string;
+    readonly environment: string;
+}
+export declare const customDomainSchema: z.ZodType<CustomDomainProperties>;
+export declare const customDomainProvider: CloudflareResourceProvider<CustomDomainProperties>;
+//# sourceMappingURL=custom-domain.d.ts.map