@infrascan/shared-types 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @infrascan/shared-types
 
+## 0.5.0
+
+### Minor Changes
+
+- [#82](https://github.com/infrascan/infrascan/pull/82) [`e28a6d9`](https://github.com/infrascan/infrascan/commit/e28a6d91eb36fa83e9a40a667eb39a15b2a45ccb) Thanks [@lfarrel6](https://github.com/lfarrel6)! - Introduce new readable/writable interface for @infrascan/core graph interface to make types nicer to work with. Previously, the graph returned union types to bridge the Graph's internal model of the state with its exposed API for adding children/parents/edges. This resulted in a lot of properties with signatures like `parent?: Node | string`.
+
+  This has been updated to wrap the Node and Edge types in `Readable` and `Writable` types based on the context they're being used in. This is inspired by the Kysely `Selectable`/`Insertable` pattern. When a Node is `Readable` its edges, parent and children will resolve to other Node objects. When `Writable`, all other Nodes are expected to be referenced using a string type containing their ID.
+
+  Introduce @infrascan/node-reducer-plugin which reduces graph complexity for dynamicially provisioned infrastructure.
+
 ## 0.4.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infrascan/shared-types",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Shared types for multiple infrascan packages",
   "main": "src/index.ts",
   "scripts": {

package/src/graph.ts

@@ -7,50 +7,83 @@ export interface SelectedNode {
   parent?: string;
   type?: string;
   rawState?: any;
-};
+}
 
 export interface SelectedEdgeTarget {
-  name: string,
-  target: string
+  name: string;
+  target: string;
 }
 
 export interface SelectedEdge {
   source: string;
   target: string;
-  metadata?: Record<string, unknown>
+  metadata?: Record<string, unknown>;
+}
+
+// Create Read/Write types inspired by kysely
+export type ElementType<ReadType, WriteType> = {
+  readonly _read: ReadType;
+  readonly _write: WriteType;
+};
+
+export type ElementRecord<K extends keyof any, R, W> = ElementType<
+  Record<K, Readable<R>>,
+  Record<K, Writable<W>>
+>;
+
+export type ReadType<T> = T extends ElementType<infer R, any> ? Readable<R> : T;
+export type Readable<T> = {
+  [K in keyof T]: ReadType<T[K]>;
+};
+
+export type WriteType<T> = T extends ElementType<any, infer W>
+  ? Writable<W>
+  : T;
+export type Writable<T> = {
+  [K in keyof T]: WriteType<T[K]>;
 };
 
 export interface Node {
-  id: string,
-  name: string,
+  id: string;
+  name: string;
   metadata: Record<string, unknown>;
-  service?: string,
-  type?: string,
-  parent?: string | Node,
-  children?: Record<string, Node>,
-  incomingEdges: Record<string, Edge<Node>>,
-  outgoingEdges: Record<string, Edge<Node>>,
+  service?: string;
+  type?: string;
+  parent?: ElementType<Node, string>;
+  children?: ElementRecord<string, Node, string>;
+  incomingEdges: ElementRecord<string, Edge, string>;
+  outgoingEdges: ElementRecord<string, Edge, string>;
 }
 
-export interface Edge<T extends string | Node> {
-  id: string,
-  name?: string,
-  metadata: Record<string, unknown>,
-  source: T,
-  target: T
+export interface Edge {
+  id: string;
+  name?: string;
+  metadata: Record<string, unknown>;
+  source: ElementType<Node, string>;
+  target: ElementType<Node, string>;
 }
 
 export interface Graph {
-  nodes: Node[],
-  edges: Edge<Node>[],
-  addNode: (node: Pick<Node, "id" | "name" | "metadata" | "parent" | "service" | "type">) => void,
-  addEdge: (edge: Pick<Edge<string>, "name" | "source" | "target" | "metadata">) => void,
-  addChild: (parent: string, child: string) => void,
-  getNode: (id: string) => Node | undefined,
-  mapNodesById: (id: string, mapperFn: (node: Node) => Node[]) => void,
-  removeEdge: (id: string) => Edge<Node>,
-  removeNode: (id: string) => Node,
-  serialize: () => string
-};
+  nodes: Readable<Node>[];
+  edges: Readable<Edge>[];
+  addNode: (
+    node: Pick<
+      Writable<Node>,
+      "id" | "name" | "metadata" | "parent" | "service" | "type"
+    >,
+  ) => void;
+  addEdge: (
+    edge: Pick<Writable<Edge>, "name" | "source" | "target" | "metadata">,
+  ) => void;
+  addChild: (parent: string, child: string) => void;
+  getNode: (id: string) => Readable<Node> | undefined;
+  mapNodesById: (
+    id: string,
+    mapperFn: (node: Readable<Node>) => Writable<Node>[],
+  ) => void;
+  removeEdge: (id: string) => Readable<Edge>;
+  removeNode: (id: string) => Readable<Node>;
+  serialize: () => string;
+}
 
-export type GraphSerializer<T> = (graph: Graph) => T;
+export type GraphSerializer<T> = (graph: Graph) => T;

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "extends": "tsconfig/base.json",
+  "extends": "@infrascan/tsconfig/base.json",
   "compilerOptions": {
     "baseUrl": "src",
     "noEmit": true,