@mizchi/k1c 0.2.0 → 0.3.0

package/dist/manifest/schemas.js

@@ -32,6 +32,8 @@ const volumeSchema = z.object({
     queueRef: z.object({ name: z.string() }).optional(),
     vectorizeRef: z.object({ name: z.string() }).optional(),
     analyticsEngineRef: z.object({ dataset: z.string() }).optional(),
+    mtlsCertificateRef: z.object({ certificateId: z.string() }).optional(),
+    pipelinesRef: z.object({ pipelineId: z.string() }).optional(),
 });
 const containerSchema = z.object({
     name: z.string(),
@@ -286,6 +288,35 @@ export const logpushJobSchema = z.object({
         message: 'LogpushJob.spec must specify exactly one of zoneId / accountId',
     }),
 });
+const ingressBackendSchema = z.object({
+    service: z.object({
+        name: z.string().min(1),
+        port: z
+            .object({
+            number: z.number().int().positive().optional(),
+            name: z.string().optional(),
+        })
+            .optional(),
+    }),
+});
+const ingressPathSchema = z.object({
+    path: z.string().min(1),
+    pathType: z.enum(['Prefix', 'Exact', 'ImplementationSpecific']),
+    backend: ingressBackendSchema,
+});
+const ingressRuleSchema = z.object({
+    host: z.string().min(1).optional(),
+    http: z.object({ paths: z.array(ingressPathSchema).min(1) }),
+});
+export const ingressSchema = z.object({
+    apiVersion: z.literal('networking.k8s.io/v1'),
+    kind: z.literal('Ingress'),
+    metadata: objectMetaSchema,
+    spec: z.object({
+        rules: z.array(ingressRuleSchema).min(1),
+        defaultBackend: ingressBackendSchema.optional(),
+    }),
+});
 export const k1cResourceSchema = z.discriminatedUnion('kind', [
     deploymentSchema,
     rolloutSchema,
@@ -305,5 +336,6 @@ export const k1cResourceSchema = z.discriminatedUnion('kind', [
     vectorizeSchema,
     dnsRecordSchema,
     logpushJobSchema,
+    ingressSchema,
 ]);
 //# sourceMappingURL=schemas.js.map

package/dist/manifest/types.d.ts

@@ -61,6 +61,12 @@ export interface Volume {
     readonly analyticsEngineRef?: {
         readonly dataset: string;
     };
+    readonly mtlsCertificateRef?: {
+        readonly certificateId: string;
+    };
+    readonly pipelinesRef?: {
+        readonly pipelineId: string;
+    };
 }
 export interface PodTemplateSpec {
     readonly metadata?: ObjectMeta;
@@ -233,7 +239,33 @@ export interface LogpushJobSpec {
     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 IngressPathType = 'Prefix' | 'Exact' | 'ImplementationSpecific';
+export interface IngressBackend {
+    readonly service: {
+        readonly name: string;
+        readonly port?: {
+            readonly number?: number;
+            readonly name?: string;
+        };
+    };
+}
+export interface IngressPath {
+    readonly path: string;
+    readonly pathType: IngressPathType;
+    readonly backend: IngressBackend;
+}
+export interface IngressRule {
+    readonly host?: string;
+    readonly http: {
+        readonly paths: ReadonlyArray<IngressPath>;
+    };
+}
+export interface IngressSpec {
+    readonly rules: ReadonlyArray<IngressRule>;
+    readonly defaultBackend?: IngressBackend;
+}
+export type Ingress = BaseResource<'Ingress', 'networking.k8s.io/v1', IngressSpec>;
+export type K1cResource = Deployment | Rollout | StatefulSet | CronJob | Job | ConfigMapResource | SecretResource | NamespaceResource | ServiceResource | R2Bucket | KVNamespace | DispatchNamespace | Hyperdrive | D1Database | Queue | Vectorize | DNSRecord | LogpushJob | Ingress;
 export type ResourceKind = K1cResource['kind'];
 export interface ResourceRef {
     readonly apiVersion: string;

package/dist/providers/worker.d.ts

@@ -100,6 +100,14 @@ export type WorkerBinding = {
     readonly type: 'analytics_engine';
     readonly name: string;
     readonly dataset: string;
+} | {
+    readonly type: 'mtls_certificate';
+    readonly name: string;
+    readonly certificateId: string;
+} | {
+    readonly type: 'pipelines';
+    readonly name: string;
+    readonly pipeline: string;
 };
 export declare const workerSchema: z.ZodType<WorkerProperties>;
 export declare const workerProvider: CloudflareResourceProvider<WorkerProperties>;

package/dist/providers/worker.js

@@ -64,6 +64,16 @@ export const workerSchema = z.object({
             name: z.string(),
             dataset: z.string(),
         }),
+        z.object({
+            type: z.literal('mtls_certificate'),
+            name: z.string(),
+            certificateId: z.string(),
+        }),
+        z.object({
+            type: z.literal('pipelines'),
+            name: z.string(),
+            pipeline: z.string(),
+        }),
     ]))
         .optional(),
     observability: z.object({ enabled: z.boolean() }).optional(),
@@ -137,6 +147,12 @@ function buildBindings(props) {
         else if (b.type === 'analytics_engine') {
             out.push({ type: 'analytics_engine', name: b.name, dataset: b.dataset });
         }
+        else if (b.type === 'mtls_certificate') {
+            out.push({ type: 'mtls_certificate', name: b.name, certificate_id: b.certificateId });
+        }
+        else if (b.type === 'pipelines') {
+            out.push({ type: 'pipelines', name: b.name, pipeline: b.pipeline });
+        }
     }
     return out;
 }
@@ -306,6 +322,12 @@ function fromCFBinding(b) {
     if (b.type === 'analytics_engine' && b.dataset !== undefined) {
         return { type: 'analytics_engine', name: b.name, dataset: b.dataset };
     }
+    if (b.type === 'mtls_certificate' && b.certificate_id !== undefined) {
+        return { type: 'mtls_certificate', name: b.name, certificateId: b.certificate_id };
+    }
+    if (b.type === 'pipelines' && b.pipeline !== undefined) {
+        return { type: 'pipelines', name: b.name, pipeline: b.pipeline };
+    }
     return null;
 }
 export const workerProvider = {

package/dist/reconciler/plan.js

@@ -102,9 +102,50 @@ function orderByDependencies(operations, desired) {
     });
     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));
+    deletes.sort((a, b) => {
+        const pa = deletePriority(a.resourceType);
+        const pb = deletePriority(b.resourceType);
+        if (pa !== pb)
+            return pa - pb;
+        return a.label.localeCompare(b.label);
+    });
     return [...sortedMutating, ...noops, ...deletes];
 }
+/**
+ * Reverse-topological priority for deletes. Smaller priority is deleted first.
+ *
+ * The reconciler has no per-instance dependency record for resources that are
+ * being deleted (they are no longer in `desired`), so we approximate the
+ * dependency direction with a static type ordering that mirrors how creates
+ * actually flow in `lower.ts`. Workers depend on data services; CustomDomain /
+ * Workflow / LogpushJob depend on Workers; DispatchNamespace hosts Workers.
+ *
+ * Unknown types fall through with a neutral priority so the sort is still stable.
+ */
+function deletePriority(resourceType) {
+    switch (resourceType) {
+        // Top-level edges — nothing else points at these. Delete first so we do not
+        // serve traffic to a Worker we are about to remove.
+        case 'CustomDomain':
+        case 'DNSRecord':
+        case 'LogpushJob':
+        case 'Workflow':
+            return 0;
+        case 'Worker':
+            return 1;
+        case 'R2Bucket':
+        case 'KVNamespace':
+        case 'D1Database':
+        case 'Hyperdrive':
+        case 'Vectorize':
+        case 'Queue':
+            return 2;
+        case 'DispatchNamespace':
+            return 3;
+        default:
+            return 1;
+    }
+}
 export function propertiesEqual(a, b) {
     return canonicalize(a) === canonicalize(b);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mizchi/k1c",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Experimental kubectl-style apply tool for Cloudflare",
   "keywords": [
     "cloudflare",