@anchrd/intel-contract 0.3.0 → 0.4.1

package/dist/contract/contract.d.ts

@@ -146,6 +146,7 @@ export declare const KnowledgeNodeList: z.ZodObject<{
         updatedAt: z.ZodISODateTime;
         archivedAt: z.ZodNullable<z.ZodISODateTime>;
     }, z.core.$strict>>;
+    withChildren: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type KnowledgeNodeList = z.infer<typeof KnowledgeNodeList>;
 export declare const KnowledgeVersionList: z.ZodObject<{
@@ -1274,6 +1275,7 @@ export declare const FlowList: z.ZodObject<{
         updatedAt: z.ZodISODateTime;
         archivedAt: z.ZodNullable<z.ZodISODateTime>;
     }, z.core.$strict>>;
+    withCalls: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type FlowList = z.infer<typeof FlowList>;
 export declare const FlowKnowledgeReference: z.ZodObject<{
@@ -1318,8 +1320,16 @@ export declare const UpdateFlowInput: z.ZodObject<{
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
 export type UpdateFlowInput = z.infer<typeof UpdateFlowInput>;
+export declare const ArchiveFlowInput: z.ZodObject<{
+    flowId: z.ZodString;
+    baseUpdatedAt: z.ZodISODateTime;
+    archived: z.ZodBoolean;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type ArchiveFlowInput = z.infer<typeof ArchiveFlowInput>;
 export declare const ListFlowsInput: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export type ListFlowsInput = z.infer<typeof ListFlowsInput>;
 export declare const GetFlowInput: z.ZodObject<{

package/dist/contract/contract.js

@@ -100,7 +100,14 @@ export const ArchiveKnowledgeNodeInput = z.strictObject({
     archived: z.boolean(),
     idempotencyKey: z.string().min(8).max(200),
 });
-export const KnowledgeNodeList = z.strictObject({ items: z.array(KnowledgeNode) });
+// ⚠️ `withChildren` gehört zur EBENE, nicht zum Knoten (#59). Ob etwas Kinder hat, die DIESER
+// Leser sehen darf, ist keine Eigenschaft der Sache — zwei Leser bekommen verschiedene Antworten.
+// Als Feld am Knoten müsste jede andere Stelle, die einen Knoten zurückgibt, es mitberechnen oder
+// lügen; als Liste neben den Einträgen kostet es nur die eine Antwort, die es braucht.
+export const KnowledgeNodeList = z.strictObject({
+    items: z.array(KnowledgeNode),
+    withChildren: z.array(IntelId).default([]),
+});
 export const KnowledgeVersionList = z.strictObject({ items: z.array(KnowledgeVersion) });
 export const KnowledgeDocument = z.strictObject({
     node: KnowledgeNode,
@@ -536,7 +543,13 @@ export const FlowDocument = z.strictObject({
     flow: Flow,
     version: FlowVersion.nullable(),
 });
-export const FlowList = z.strictObject({ items: z.array(Flow) });
+// Dasselbe für Flows: welche von ihnen einen anderen Flow rufen, den dieser Leser auch sehen darf
+// (#59). Ein Aufklapp-Pfeil an einem Flow, dessen Aufrufe alle verborgen sind, verspricht Inhalt,
+// den das Aufklappen nicht liefern kann.
+export const FlowList = z.strictObject({
+    items: z.array(Flow),
+    withCalls: z.array(IntelId).default([]),
+});
 export const FlowKnowledgeReference = z.strictObject({
     id: IntelId,
     title: z.string().min(1).max(240),
@@ -591,11 +604,29 @@ export const UpdateFlowInput = z
     idempotencyKey: z.string().min(8).max(200),
 })
     .refine((input) => input.title !== undefined || input.description !== undefined || input.parentId !== undefined, { error: "At least one change is required" });
+// Archiving a flow is the same shape as archiving a document, deliberately: `archived` is a boolean
+// rather than a one-way verb, because an archive nothing returns from is a delete under a friendlier
+// name. Restoring is the same call with `false`.
+export const ArchiveFlowInput = z.strictObject({
+    flowId: IntelId,
+    baseUpdatedAt: IsoDateTime,
+    archived: z.boolean(),
+    idempotencyKey: z.string().min(8).max(200),
+});
 // Three answers, not two: an absent `parentId` lists every visible flow (the search dialog asks
 // that), `null` lists the root of the shared tree and an ID lists one folder (the sidebar tree asks
 // per level, which is what keeps the tree off the N+1 it used to load with).
 export const ListFlowsInput = z.strictObject({
     parentId: IntelId.nullable().optional(),
+    // The only way back to an archived flow, and the only place that asks for one: the bounded read
+    // behind the relation graph has no such flag on purpose (#30). A drawing that includes what was
+    // archived says the tidying up never happened.
+    //
+    // ⚠️ `.optional()` rather than `.default(false)`, unlike `ListKnowledgeNodesInput`. This schema is
+    // the argument type of `listFlows` on three layers, and a default makes the field required in the
+    // *parsed* type — every existing caller that lists a folder would have to spell out the answer to
+    // a question it is not asking. Absent means "without the archive" everywhere it is read.
+    includeArchived: z.boolean().optional(),
 });
 export const GetFlowInput = z.strictObject({ flowId: IntelId });
 export const SaveFlowVersionInput = z.strictObject({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-contract",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {