@cosmicdrift/kumiko-samples 0.398.0 → 0.400.0

package/samples/recipes/inspection-checklist/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@cosmicdrift/kumiko-sample-inspection-checklist",
+  "description": "Embedded list as a phone inspection checklist: conditional fields, derived pass/fail, photos per row.",
+  "private": true,
+  "dependencies": {
+    "@cosmicdrift/kumiko-bundled-features": "workspace:*",
+    "@cosmicdrift/kumiko-framework": "workspace:*"
+  },
+  "devDependencies": {
+    "@cosmicdrift/kumiko-testing": "workspace:*"
+  }
+}

package/samples/recipes/inspection-checklist/src/entities/inspection-plan.ts

@@ -0,0 +1,24 @@
+import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEmbeddedListField,
+  createEntity,
+  createTextField,
+} from "@cosmicdrift/kumiko-framework/engine";
+
+export const inspectionPlanEntity = createEntity({
+  table: "read_sample_inspection_plans",
+  fields: {
+    name: createTextField({ personal: false, reason: "is_business_data", required: true }),
+    checkpoints: createEmbeddedListField(
+      {
+        label: { type: "text", required: true },
+        kind: { type: "select", options: ["check", "measurement"], required: true },
+        min: { type: "number" },
+        max: { type: "number" },
+      },
+      { personal: false, reason: "is_business_data" },
+    ),
+  },
+});
+
+export const inspectionPlanTable = buildEntityTable("inspection-plan", inspectionPlanEntity);

package/samples/recipes/inspection-checklist/src/entities/inspection-protocol.ts

@@ -0,0 +1,72 @@
+import { buildEntityTable } from "@cosmicdrift/kumiko-framework/db";
+import {
+  createEmbeddedListField,
+  createEntity,
+  createSelectField,
+  createTextField,
+} from "@cosmicdrift/kumiko-framework/engine";
+
+const isMeasurement = { field: "kind", eq: "measurement" } as const;
+const isNotOk = { field: "result", eq: "not_ok" } as const;
+
+export const inspectionProtocolEntity = createEntity({
+  table: "read_sample_inspection_protocols",
+  fields: {
+    measuringDevice: createTextField({ personal: false, reason: "is_business_data" }),
+    checkpoints: createEmbeddedListField(
+      {
+        label: { type: "text", required: true },
+        kind: { type: "select", options: ["check", "measurement"], required: true },
+        min: { type: "number", visibleWhen: isMeasurement },
+        max: { type: "number", visibleWhen: isMeasurement },
+        measured: { type: "number", visibleWhen: isMeasurement },
+        result: {
+          type: "select",
+          options: ["ok", "not_ok"],
+          display: "radio",
+          optionTones: { ok: "ok", not_ok: "bad" },
+        },
+        finding: { type: "text", visibleWhen: isNotOk, requiredWhen: isNotOk },
+        photos: {
+          type: "images",
+          capture: "environment",
+          maxCount: 5,
+          accept: ["jpg", "jpeg", "png"],
+          visibleWhen: isNotOk,
+          requiredWhen: isNotOk,
+        },
+        documents: { type: "files", maxCount: 3 },
+        approvedBy: { type: "text", access: { write: ["Admin"] } },
+      },
+      {
+        personal: false,
+        reason: "is_business_data",
+        derived: {
+          result: {
+            op: "inRange",
+            from: ["measured", "min", "max"],
+            inside: "ok",
+            outside: "not_ok",
+            when: isMeasurement,
+          },
+        },
+      },
+    ),
+    continuedOperation: createSelectField({
+      options: ["yes", "with_condition", "no"],
+      display: "radio",
+      optionTones: { yes: "ok", with_condition: "warn", no: "bad" },
+    }),
+    condition: createTextField({
+      personal: false,
+      reason: "is_business_data",
+      visibleWhen: { field: "continuedOperation", eq: "with_condition" },
+      requiredWhen: { field: "continuedOperation", eq: "with_condition" },
+    }),
+  },
+});
+
+export const inspectionProtocolTable = buildEntityTable(
+  "inspection-protocol",
+  inspectionProtocolEntity,
+);

package/samples/recipes/inspection-checklist/src/feature.ts

@@ -0,0 +1,33 @@
+// Inspection Checklist Sample
+// Shows: an embedded list as a phone inspection checklist.
+//   - visibleWhen / requiredWhen on cells and top-level fields (server-enforced)
+//   - a derived pass/fail cell (inRange) that the server recomputes
+//   - an images cell per row, uploaded with the `subField` multipart part
+//   - fixed rows copied from a plan, only the result cells stay editable
+
+import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import { inspectionPlanEntity } from "./entities/inspection-plan";
+import { inspectionProtocolEntity } from "./entities/inspection-protocol";
+import { createFromPlan } from "./handlers/create-from-plan.write";
+import { inspectionProtocolEditScreen } from "./screens/inspection-protocol-edit.screen";
+
+export { inspectionPlanEntity } from "./entities/inspection-plan";
+export { inspectionProtocolEntity } from "./entities/inspection-protocol";
+
+const inspectorAccess = { access: { roles: ["Admin", "Inspector"] } } as const;
+
+export const inspectionChecklistFeature = defineFeature("inspection-checklist", (r) => {
+  r.requires({ features: ["files"] });
+
+  r.crud("inspection-plan", inspectionPlanEntity, {
+    write: inspectorAccess,
+    read: inspectorAccess,
+  });
+  r.crud("inspection-protocol", inspectionProtocolEntity, {
+    write: inspectorAccess,
+    read: inspectorAccess,
+  });
+  r.writeHandler(createFromPlan);
+
+  r.screen(inspectionProtocolEditScreen);
+});

package/samples/recipes/inspection-checklist/src/handlers/create-from-plan.write.ts

@@ -0,0 +1,38 @@
+import { createEntityExecutor, defineWriteHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { failNotFound } from "@cosmicdrift/kumiko-framework/errors";
+import { z } from "zod";
+import { inspectionPlanEntity } from "../entities/inspection-plan";
+import { inspectionProtocolEntity } from "../entities/inspection-protocol";
+
+const { executor: planExecutor } = createEntityExecutor("inspection-plan", inspectionPlanEntity);
+const { executor: protocolExecutor } = createEntityExecutor(
+  "inspection-protocol",
+  inspectionProtocolEntity,
+);
+
+const planRows = z.array(
+  z.object({
+    label: z.string(),
+    kind: z.enum(["check", "measurement"]),
+    min: z.number().optional(),
+    max: z.number().optional(),
+  }),
+);
+
+// Copies only the plan's fixed columns; result, finding and photos stay empty for the inspector.
+export const createFromPlan = defineWriteHandler({
+  name: "inspection-protocol:create-from-plan",
+  schema: z.object({ planId: z.uuid() }),
+  access: { roles: ["Admin", "Inspector"] },
+  handler: async (event, ctx) => {
+    const plan = await planExecutor.detail({ id: event.payload.planId }, event.user, ctx.db);
+    if (!plan) return failNotFound("inspection-plan", event.payload.planId);
+    const checkpoints = planRows.parse(plan["checkpoints"]).map(({ label, kind, min, max }) => ({
+      label,
+      kind,
+      ...(min !== undefined ? { min } : {}),
+      ...(max !== undefined ? { max } : {}),
+    }));
+    return protocolExecutor.create({ checkpoints }, event.user, ctx.db);
+  },
+});

package/samples/recipes/inspection-checklist/src/screens/inspection-protocol-edit.screen.ts

@@ -0,0 +1,27 @@
+import type { EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/engine";
+
+export const inspectionProtocolEditScreen: EntityEditScreenDefinition = {
+  id: "inspection-protocol-edit",
+  type: "entityEdit",
+  entity: "inspection-protocol",
+  layout: {
+    width: "full",
+    sections: [
+      {
+        columns: 1,
+        fields: [
+          "measuringDevice",
+          {
+            field: "checkpoints",
+            embeddedList: {
+              readOnlyCells: ["label", "kind", "min", "max"],
+              cardHiddenCells: ["kind"],
+              fixedRows: true,
+            },
+          },
+        ],
+      },
+      { columns: 1, fields: ["continuedOperation", "condition"] },
+    ],
+  },
+};