chore: Fix the tests and add new types for raw

lib/config/builder/config.ts

@@ -1,4 +1,4 @@
-import { InputSpec, ValueSpec } from "../config-types";
+import { InputSpec, ValueSpec } from "../configTypes";
 import { typeFromProps } from "../../util";
 import { BuilderExtract, IBuilder } from "./builder";
 import { Value } from "./value";
@@ -63,16 +63,10 @@ export class Config<A extends InputSpec> extends IBuilder<A> {
   static empty() {
     return new Config({});
   }
-  static withValue<K extends string, B extends ValueSpec>(
+  static withValue<K extends string, B extends ValueSpec>(key: K, value: Value<B>) {
-    key: K,
-    value: Value<B>
-  ) {
     return Config.empty().withValue(key, value);
   }
-  static addValue<K extends string, B extends ValueSpec>(
+  static addValue<K extends string, B extends ValueSpec>(key: K, value: Value<B>) {
-    key: K,
-    value: Value<B>
-  ) {
     return Config.empty().withValue(key, value);
   }
 

lib/config/builder/list.ts

@@ -1,6 +1,6 @@
 import { BuilderExtract, IBuilder } from "./builder";
 import { Config } from "./config";
-import { InputSpec, ListValueSpecNumber, ListValueSpecString, UniqueBy, ValueSpecList } from "../config-types";
+import { InputSpec, ListValueSpecNumber, ListValueSpecString, UniqueBy, ValueSpecList } from "../configTypes";
 import { guardAll } from "../../util";
 /**
  * Used as a subtype of Value.list

lib/config/builder/value.ts

@@ -9,9 +9,9 @@ import {
   ValueSpecList,
   ValueSpecNumber,
   ValueSpecTextarea,
-} from "../config-types";
+} from "../configTypes";
 import { guardAll } from "../../util";
-import { DefaultString } from "../config-types";
+import { DefaultString } from "../configTypes";
 /**
  * A value is going to be part of the form in the FE of the OS.
  * Something like a boolean, a string, a number, etc.
@@ -35,12 +35,7 @@ const username = Value.string({
  ```
  */
 export class Value<A extends ValueSpec> extends IBuilder<A> {
-  static boolean(a: {
+  static boolean(a: { name: string; description?: string | null; warning?: string | null; default?: boolean | null }) {
-    name: string;
-    description?: string | null;
-    warning?: string | null;
-    default?: boolean | null;
-  }) {
     return new Value({
       description: null,
       warning: null,
@@ -166,9 +161,7 @@ export class Value<A extends ValueSpec> extends IBuilder<A> {
       spec,
     });
   }
-  static union<
+  static union<V extends Variants<{ [key: string]: { name: string; spec: InputSpec } }>>(
-    V extends Variants<{ [key: string]: { name: string; spec: InputSpec } }>
-  >(
     a: {
       name: string;
       description?: string | null;

lib/config/builder/variants.ts

@@ -1,4 +1,4 @@
-import { InputSpec } from "../config-types";
+import { InputSpec } from "../configTypes";
 import { BuilderExtract, IBuilder } from "./builder";
 import { Config } from ".";
 
@@ -80,10 +80,7 @@ export class Variants<
   static empty() {
     return Variants.of({});
   }
-  static withVariant<K extends string, B extends InputSpec>(
+  static withVariant<K extends string, B extends InputSpec>(key: K, value: Config<B>) {
-    key: K,
-    value: Config<B>
-  ) {
     return Variants.empty().withVariant(key, value);
   }
 

lib/config/configTypes.ts

@@ -0,0 +1,53 @@
+import * as C from "./configTypesRaw";
+
+export type ValueType = C.ValueType;
+// prettier-ignore
+export type WithOutOptionals<A> = 
+  A extends Record<string | number, unknown> ? {[k in keyof A]: A[k]} :
+  A;
+
+export type InputSpec = Record<string, WithOutOptionals<C.ValueSpec>>;
+
+export type ValueSpec = WithOutOptionals<C.ValueSpec>;
+
+/** core spec types. These types provide the metadata for performing validations */
+export type ValueSpecOf<T extends ValueType> = WithOutOptionals<C.ValueSpecOf<T>>;
+
+export type ValueSpecString = WithOutOptionals<C.ValueSpecString>;
+export type ValueSpecTextarea = WithOutOptionals<C.ValueSpecTextarea>;
+export type ValueSpecNumber = WithOutOptionals<C.ValueSpecNumber>;
+export type ValueSpecSelect = WithOutOptionals<C.ValueSpecSelect>;
+export type ValueSpecMultiselect = WithOutOptionals<C.ValueSpecMultiselect>;
+export type ValueSpecBoolean = WithOutOptionals<C.ValueSpecBoolean>;
+export type ValueSpecUnion = WithOutOptionals<C.ValueSpecUnion>;
+export type ValueSpecFile = WithOutOptionals<C.ValueSpecFile>;
+export type ValueSpecObject = WithOutOptionals<C.ValueSpecObject>;
+export type WithStandalone = WithOutOptionals<C.WithStandalone>;
+export type SelectBase = WithOutOptionals<C.SelectBase>;
+export type ListValueSpecType = WithOutOptionals<C.ListValueSpecType>;
+
+/** represents a spec for the values of a list */
+export type ListValueSpecOf<T extends ListValueSpecType> = WithOutOptionals<C.ListValueSpecOf<T>>;
+
+/** represents a spec for a list */
+export type ValueSpecList = WithOutOptionals<C.ValueSpecList>;
+export type ValueSpecListOf<T extends ListValueSpecType> = WithOutOptionals<C.ValueSpecListOf<T>>;
+
+// sometimes the type checker needs just a little bit of help
+export function isValueSpecListOf<S extends ListValueSpecType>(
+  t: ValueSpecListOf<ListValueSpecType>,
+  s: S
+): t is ValueSpecListOf<S> & { spec: ListValueSpecOf<S> } {
+  return t.spec.type === s;
+}
+export type ListValueSpecString = WithOutOptionals<C.ListValueSpecString>;
+export type ListValueSpecNumber = WithOutOptionals<C.ListValueSpecNumber>;
+export type ListValueSpecObject = WithOutOptionals<C.ListValueSpecObject>;
+export type UniqueBy = WithOutOptionals<C.UniqueBy>;
+export type DefaultString = WithOutOptionals<C.DefaultString>;
+
+export const unionSelectKey = "unionSelectKey" as const;
+export type UnionSelectKey = typeof unionSelectKey;
+
+export const unionValueKey = "unionValueKey" as const;
+export type UnionValueKey = typeof unionValueKey;

lib/config/configTypesRaw.ts

@@ -1,5 +1,4 @@
-export type InputSpec = Record<string, ValueSpec>;
+export type InputSpecRaw = Record<string, ValueSpec>;
-
 export type ValueType =
   | "string"
   | "textarea"
@@ -12,7 +11,6 @@ export type ValueType =
   | "file"
   | "union";
 export type ValueSpec = ValueSpecOf<ValueType>;
-
 /** core spec types. These types provide the metadata for performing validations */
 export type ValueSpecOf<T extends ValueType> = T extends "string"
   ? ValueSpecString
@@ -35,71 +33,64 @@ export type ValueSpecOf<T extends ValueType> = T extends "string"
   : T extends "union"
   ? ValueSpecUnion
   : never;
-
 export interface ValueSpecString extends ListValueSpecString, WithStandalone {
   required: boolean;
-  default: DefaultString | null;
+  default?: DefaultString | null;
 }
-
 export interface ValueSpecTextarea extends WithStandalone {
   type: "textarea";
-  placeholder: string | null;
+  placeholder?: string | null;
   required: boolean;
 }
-
 export interface ValueSpecNumber extends ListValueSpecNumber, WithStandalone {
   required: boolean;
-  default: number | null;
+  default?: number | null;
 }
-
 export interface ValueSpecSelect extends SelectBase, WithStandalone {
   type: "select";
   required: boolean;
-  default: string | null;
+  default?: string | null;
 }
-
 export interface ValueSpecMultiselect extends SelectBase, WithStandalone {
   type: "multiselect";
   /**'[0,1]' (inclusive) OR '[0,*)' (right unbounded), normal math rules */
-  range: string;
+  range?: string;
-  default: string[];
+  default?: string[];
 }
-
 export interface ValueSpecBoolean extends WithStandalone {
   type: "boolean";
-  default: boolean | null;
+  default?: boolean | null;
 }
-
 export interface ValueSpecUnion extends WithStandalone {
   type: "union";
-  variants: Record<string, { name: string; spec: InputSpec }>;
+  variants: Record<
+    string,
+    {
+      name: string;
+      spec: InputSpecRaw;
+    }
+  >;
   required: boolean;
-  default: string | null;
+  default?: string | null;
 }
-
 export interface ValueSpecFile extends WithStandalone {
   type: "file";
   extensions: string[];
   required: boolean;
 }
-
 export interface ValueSpecObject extends WithStandalone {
   type: "object";
-  spec: InputSpec;
+  spec: InputSpecRaw;
 }
-
 export interface WithStandalone {
   name: string;
-  description: string | null;
+  description?: string | null;
-  warning: string | null;
+  warning?: string | null;
 }
-
 export interface SelectBase {
   values: Record<string, string>;
 }
-
 export type ListValueSpecType = "string" | "number" | "object";
-
 /** represents a spec for the values of a list */
 export type ListValueSpecOf<T extends ListValueSpecType> = T extends "string"
   ? ListValueSpecString
@@ -108,15 +99,13 @@ export type ListValueSpecOf<T extends ListValueSpecType> = T extends "string"
   : T extends "object"
   ? ListValueSpecObject
   : never;
-
 /** represents a spec for a list */
 export type ValueSpecList = ValueSpecListOf<ListValueSpecType>;
-export interface ValueSpecListOf<T extends ListValueSpecType>
+export interface ValueSpecListOf<T extends ListValueSpecType> extends WithStandalone {
-  extends WithStandalone {
   type: "list";
   spec: ListValueSpecOf<T>;
-  range: string; // '[0,1]' (inclusive) OR '[0,*)' (right unbounded), normal math rules
+  range?: string;
-  default:
+  default?:
     | string[]
     | number[]
     | DefaultString[]
@@ -126,53 +115,48 @@ export interface ValueSpecListOf<T extends ListValueSpecType>
     | readonly DefaultString[]
     | readonly Record<string, unknown>[];
 }
-
+export declare function isValueSpecListOf<S extends ListValueSpecType>(
-// sometimes the type checker needs just a little bit of help
-export function isValueSpecListOf<S extends ListValueSpecType>(
   t: ValueSpecListOf<ListValueSpecType>,
   s: S
-): t is ValueSpecListOf<S> & { spec: ListValueSpecOf<S> } {
+): t is ValueSpecListOf<S> & {
-  return t.spec.type === s;
+  spec: ListValueSpecOf<S>;
-}
+};
-
 export interface ListValueSpecString {
   type: "string";
-  pattern: string | null;
+  pattern?: string | null;
-  patternDescription: string | null;
+  patternDescription?: string | null;
-  masked: boolean; // default = false
+  masked?: boolean;
-  inputmode: "text" | "email" | "tel" | "url"; // default = 'text'
+  inputmode?: "text" | "email" | "tel" | "url";
-  placeholder: string | null;
+  placeholder?: string | null;
 }
-
 export interface ListValueSpecNumber {
   type: "number";
-  /** '[0,1]' (inclusive) OR '[0,*)' (right unbounded), normal math rules */
+  range?: string;
-  range: string;
+  integral: boolean;
-  integral: boolean; // default = false
+  units?: string | null;
-  units: string | null;
+  placeholder?: string | null;
-  placeholder: string | null;
 }
-
 export interface ListValueSpecObject {
   type: "object";
   /** this is a mapped type of the config object at this level, replacing the object's values with specs on those values */
-  spec: InputSpec;
+  spec: InputSpecRaw;
   /** indicates whether duplicates can be permitted in the list */
   uniqueBy: UniqueBy;
   /** this should be a handlebars template which can make use of the entire config which corresponds to 'spec' */
-  displayAs: string | null;
+  displayAs?: string | null;
 }
-
 export type UniqueBy =
   | null
   | string
-  | { any: readonly UniqueBy[] | UniqueBy[] }
+  | {
-  | { all: readonly UniqueBy[] | UniqueBy[] };
+      any: readonly UniqueBy[] | UniqueBy[];
-
+    }
-export type DefaultString = string | { charset: string; len: number };
+  | {
-
+      all: readonly UniqueBy[] | UniqueBy[];
-export declare const unionSelectKey: "unionSelectKey";
+    };
-export type UnionSelectKey = typeof unionSelectKey;
+export type DefaultString =
-
+  | string
-export declare const unionValueKey: "unionValueKey";
+  | {
-export type UnionValueKey = typeof unionValueKey;
+      charset: string;
+      len: number;
+    };

lib/config/index.ts

@@ -1,3 +1,3 @@
 export * as configBuilder from "./builder";
 
-export { setupConfigExports } from "./setup_config_export";
+export { setupConfigExports } from "./setupConfigExports";

lib/config/setupConfigExports.ts

@@ -1,6 +1,6 @@
 import { Config } from "./builder";
 import { DeepPartial, DependsOn, Effects, ExpectedExports } from "../types";
-import { InputSpec } from "./config-types";
+import { InputSpec } from "./configTypes";
 import { nullIfEmpty } from "../util";
 import { TypeFromProps } from "../util/propertiesMatcher";
 

lib/index.ts

@@ -7,6 +7,6 @@ export * as healthUtil from "./health/util";
 export * as util from "./util";
 export * as configBuilder from "./config/builder";
 export * as backup from "./backup";
-export * as configTypes from "./config/config-types";
+export * as configTypes from "./config/configTypes";
 export * as config from "./config";
 export * as health from "./health";

lib/test/configBuilder.test.ts

@@ -3,6 +3,7 @@ import { Config } from "../config/builder/config";
 import { List } from "../config/builder/list";
 import { Value } from "../config/builder/value";
 import { Variants } from "../config/builder/variants";
+import { Parser } from "ts-matches";
 
 describe("builder tests", () => {
   test("String", () => {
@@ -138,9 +139,9 @@ describe("values", () => {
       })
     );
     const validator = value.validator();
-    validator.unsafeCast({ unionSelectKey: "a", unionSelectValue: { b: false } });
+    validator.unsafeCast({ unionSelectKey: "a", unionValueKey: { b: false } });
     type Test = typeof validator._TYPE;
-    testOutput<Test, { unionSelectKey: "a" } & { unionSelectValue:  { b: boolean } }>()(null);
+    testOutput<Test, { unionSelectKey: "a" } & { unionValueKey: { b: boolean } }>()(null);
   });
   test("list", () => {
     const value = Value.list(

lib/test/configTypes.test.ts

@@ -1,4 +1,4 @@
-import { ListValueSpecOf, ValueSpecList, isValueSpecListOf } from "../config/config-types";
+import { ListValueSpecOf, ValueSpecList, isValueSpecListOf } from "../config/configTypes";
 import { Config } from "../config/builder/config";
 import { List } from "../config/builder/list";
 import { Value } from "../config/builder/value";

lib/test/makeOutput.ts

@@ -18,8 +18,7 @@ writeConvertedFile(
         tag: {
           id: "type",
           name: "Type",
-          description:
+          description: "- LND: Lightning Network Daemon from Lightning Labs\n- CLN: Core Lightning from Blockstream\n",
-            "- LND: Lightning Network Daemon from Lightning Labs\n- CLN: Core Lightning from Blockstream\n",
           "variant-names": {
             lnd: "Lightning Network Daemon (LND)",
             "c-lightning": "Core Lightning (CLN)",
@@ -58,8 +57,7 @@ writeConvertedFile(
           default: "bitcoin",
           masked: true,
           pattern: "^[a-zA-Z0-9_]+$",
-          "pattern-description":
+          "pattern-description": "Must be alphanumeric (can contain underscore).",
-            "Must be alphanumeric (can contain underscore).",
         },
         password: {
           type: "string",
@@ -71,8 +69,7 @@ writeConvertedFile(
             len: 20,
           },
           pattern: '^[^\\n"]*$',
-          "pattern-description":
+          "pattern-description": "Must not contain newline or quote characters.",
-            "Must not contain newline or quote characters.",
           copyable: true,
           masked: true,
         },
@@ -84,8 +81,7 @@ writeConvertedFile(
           default: "bitcoin",
           masked: true,
           pattern: "^[a-zA-Z0-9_]+$",
-          "pattern-description":
+          "pattern-description": "Must be alphanumeric (can contain underscore).",
-            "Must be alphanumeric (can contain underscore).",
           textarea: true,
         },
         advanced: {
@@ -101,18 +97,15 @@ writeConvertedFile(
               subtype: "string",
               default: [],
               spec: {
-                pattern:
+                pattern: "^[a-zA-Z0-9_-]+:([0-9a-fA-F]{2})+\\$([0-9a-fA-F]{2})+$",
-                  "^[a-zA-Z0-9_-]+:([0-9a-fA-F]{2})+\\$([0-9a-fA-F]{2})+$",
+                "pattern-description": 'Each item must be of the form "<USERNAME>:<SALT>$<HASH>".',
-                "pattern-description":
-                  'Each item must be of the form "<USERNAME>:<SALT>$<HASH>".',
                 masked: false,
               },
               range: "[0,*)",
             },
             serialversion: {
               name: "Serialization Version",
-              description:
+              description: "Return raw transaction or block hex with Segwit or non-SegWit serialization.",
-                "Return raw transaction or block hex with Segwit or non-SegWit serialization.",
               type: "enum",
               values: ["non-segwit", "segwit"],
               "value-names": {},
@@ -120,8 +113,7 @@ writeConvertedFile(
             },
             servertimeout: {
               name: "Rpc Server Timeout",
-              description:
+              description: "Number of seconds after which an uncompleted RPC call will time out.",
-                "Number of seconds after which an uncompleted RPC call will time out.",
               type: "number",
               nullable: false,
               range: "[5,300]",
@@ -224,8 +216,7 @@ writeConvertedFile(
               type: "number",
               nullable: false,
               name: "Max Mempool Size",
-              description:
+              description: "Keep the transaction memory pool below <n> megabytes.",
-                "Keep the transaction memory pool below <n> megabytes.",
               range: "[1,*)",
               integral: true,
               units: "MiB",
@@ -235,8 +226,7 @@ writeConvertedFile(
               type: "number",
               nullable: false,
               name: "Mempool Expiration",
-              description:
+              description: "Do not keep transactions in the mempool longer than <n> hours.",
-                "Do not keep transactions in the mempool longer than <n> hours.",
               range: "[1,*)",
               integral: true,
               units: "Hr",
@@ -252,8 +242,7 @@ writeConvertedFile(
             listen: {
               type: "boolean",
               name: "Make Public",
-              description:
+              description: "Allow other nodes to find your server on the network.",
-                "Allow other nodes to find your server on the network.",
               default: true,
             },
             onlyconnect: {
@@ -293,8 +282,7 @@ writeConvertedFile(
                     type: "number",
                     nullable: true,
                     name: "Port",
-                    description:
+                    description: "Port that peer is listening on for inbound p2p connections",
-                      "Port that peer is listening on for inbound p2p connections",
                     range: "[0,65535]",
                     integral: true,
                   },
@@ -318,8 +306,7 @@ writeConvertedFile(
         pruning: {
           type: "union",
           name: "Pruning Settings",
-          description:
+          description: "Blockchain Pruning Options\nReduce the blockchain size on disk\n",
-            "Blockchain Pruning Options\nReduce the blockchain size on disk\n",
           warning:
             "If you set pruning to Manual and your disk is smaller than the total size of the blockchain, you MUST have something running that prunes these blocks or you may overfill your disk!\nDisabling pruning will convert your node into a full archival node. This requires a resync of the entire blockchain, a process that may take several days. Make sure you have enough free disk space or you may fill up your disk.\n",
           tag: {
@@ -341,8 +328,7 @@ writeConvertedFile(
                 nullable: false,
                 name: "Max Chain Size",
                 description: "Limit of blockchain size on disk.",
-                warning:
+                warning: "Increasing this value will require re-syncing your node.",
-                  "Increasing this value will require re-syncing your node.",
                 default: 550,
                 range: "[550,1000000)",
                 integral: true,

lib/test/output.test.ts

@@ -1,9 +1,8 @@
-import { UnionSelectKey, unionSelectKey } from "../config/config-types";
+import { Parser } from "ts-matches";
-import { InputSpec, matchInputSpec } from "./output";
+import { UnionSelectKey, unionSelectKey, UnionValueKey, unionValueKey } from "../config/configTypes";
+import { InputSpec, matchInputSpec, testListUnion } from "./output";
 
-export type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T
+export type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2
-  ? 1
-  : 2) extends <G>() => G extends U ? 1 : 2
   ? Y
   : N;
 export function testOutput<A, B>(): (c: IfEquals<A, B>) => null {
@@ -13,11 +12,7 @@ export function testOutput<A, B>(): (c: IfEquals<A, B>) => null {
 function isObject(item: unknown): item is object {
   return !!(item && typeof item === "object" && !Array.isArray(item));
 }
-type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
-  x: infer R
-) => any
-  ? R
-  : never;
 export function mergeDeep<A extends unknown[]>(...sources: A) {
   return _mergeDeep({}, ...sources);
 }
@@ -49,21 +44,11 @@ testOutput<InputSpec["rpc"]["enable"], boolean>()(null);
 testOutput<InputSpec["rpc"]["username"], string>()(null);
 
 testOutput<InputSpec["rpc"]["advanced"]["auth"], string[]>()(null);
-testOutput<
+testOutput<InputSpec["rpc"]["advanced"]["serialversion"], "segwit" | "non-segwit">()(null);
-  InputSpec["rpc"]["advanced"]["serialversion"],
-  "segwit" | "non-segwit"
->()(null);
 testOutput<InputSpec["rpc"]["advanced"]["servertimeout"], number>()(null);
-testOutput<InputSpec["advanced"]["peers"]["addnode"][0]["hostname"], string>()(
+testOutput<InputSpec["advanced"]["peers"]["addnode"][0]["hostname"], string>()(null);
-  null
+testOutput<InputSpec["testListUnion"][0]["union"][UnionValueKey]["name"], string>()(null);
-);
+testOutput<InputSpec["testListUnion"][0]["union"][UnionSelectKey], "lnd">()(null);
-testOutput<InputSpec["testListUnion"][0][UnionSelectKey]["name"], string>()(
-  null
-);
-testOutput<
-  InputSpec["testListUnion"][0][UnionSelectKey][UnionSelectKey],
-  "lnd"
->()(null);
 // prettier-ignore
 // @ts-expect-error Expect that the string is the one above
 testOutput<InputSpec["testListUnion"][0][UnionSelectKey][UnionSelectKey], "unionSelectKey">()(null);
@@ -73,7 +58,7 @@ describe("Inputs", () => {
   const validInput: InputSpec = {
     testListUnion: [
       {
-        [unionSelectKey]: { [unionSelectKey]: "lnd", name: "string" },
+        union: { [unionSelectKey]: "lnd", [unionValueKey]: { name: "string" } },
       },
     ],
     rpc: {
@@ -112,7 +97,8 @@ describe("Inputs", () => {
       },
       dbcache: 5,
       pruning: {
-        [unionSelectKey]: "disabled",
+        unionSelectKey: "disabled",
+        unionValueKey: {},
       },
       blockfilters: {
         blockfilterindex: false,
@@ -121,19 +107,19 @@ describe("Inputs", () => {
       bloomfilters: { peerbloomfilters: false },
     },
   };
+
+  test("Test just the input unions", () => {
+    testListUnion.validator().unsafeCast(validInput.testListUnion);
+  });
   test("test valid input", () => {
     const output = matchInputSpec.unsafeCast(validInput);
     expect(output).toEqual(validInput);
   });
   test("test errors", () => {
     expect(() =>
-      matchInputSpec.unsafeCast(
+      matchInputSpec.unsafeCast(mergeDeep(validInput, { rpc: { advanced: { threads: 0 } } }))
-        mergeDeep(validInput, { rpc: { advanced: { threads: 0 } } })
-      )
-    ).toThrowError();
-    expect(() =>
-      matchInputSpec.unsafeCast(mergeDeep(validInput, { rpc: { enable: 2 } }))
     ).toThrowError();
+    expect(() => matchInputSpec.unsafeCast(mergeDeep(validInput, { rpc: { enable: 2 } }))).toThrowError();
 
     expect(() =>
       matchInputSpec.unsafeCast(
@@ -142,6 +128,5 @@ describe("Inputs", () => {
         })
       )
     ).toThrowError();
-    matchInputSpec.unsafeCast(validInput);
   });
 });

lib/types.ts

@@ -1,42 +1,27 @@
-export * as configTypes from "./config/config-types";
+export * as configTypes from "./config/configTypes";
-import { InputSpec } from "./config/config-types";
+import { InputSpec } from "./config/configTypes";
 
 export namespace ExpectedExports {
   version: 1;
   /** Set configuration is called after we have modified and saved the configuration in the embassy ui. Use this to make a file for the docker to read from for configuration.  */
-  export type setConfig = (options: {
+  export type setConfig = (options: { effects: Effects; input: Record<string, unknown> }) => Promise<unknown>;
-    effects: Effects;
-    input: Record<string, unknown>;
-  }) => Promise<unknown>;
   /** Get configuration returns a shape that describes the format that the embassy ui will generate, and later send to the set config  */
-  export type getConfig = (options: {
+  export type getConfig = (options: { effects: Effects; config: unknown }) => Promise<ConfigRes>;
-    effects: Effects;
-    config: unknown;
-  }) => Promise<ConfigRes>;
   /** These are how we make sure the our dependency configurations are valid and if not how to fix them. */
   export type dependencies = Dependencies;
   /** For backing up service data though the embassyOS UI */
-  export type createBackup = (options: {
+  export type createBackup = (options: { effects: Effects }) => Promise<unknown>;
-    effects: Effects;
-  }) => Promise<unknown>;
   /** For restoring service data that was previously backed up using the embassyOS UI create backup flow. Backup restores are also triggered via the embassyOS UI, or doing a system restore flow during setup. */
-  export type restoreBackup = (options: {
+  export type restoreBackup = (options: { effects: Effects }) => Promise<unknown>;
-    effects: Effects;
-  }) => Promise<unknown>;
   /**  Properties are used to get values from the docker, like a username + password, what ports we are hosting from */
-  export type properties = (options: {
+  export type properties = (options: { effects: Effects }) => Promise<Properties>;
-    effects: Effects;
-  }) => Promise<Properties>;
 
   /** Health checks are used to determine if the service is working properly after starting
    * A good use case is if we are using a web server, seeing if we can get to the web server.
    */
   export type health = {
     /** Should be the health check id */
-    [id: string]: (options: {
+    [id: string]: (options: { effects: Effects; input: TimeMs }) => Promise<unknown>;
-      effects: Effects;
-      input: TimeMs;
-    }) => Promise<unknown>;
   };
 
   /**
@@ -45,36 +30,24 @@ export namespace ExpectedExports {
    * service starting, and that file would indicate that it would rescan all the data.
    */
   export type action = {
-    [id: string]: (options: {
+    [id: string]: (options: { effects: Effects; input?: Record<string, unknown> }) => Promise<ActionResult>;
-      effects: Effects;
-      input?: Record<string, unknown>;
-    }) => Promise<ActionResult>;
   };
 
   /**
    * This is the entrypoint for the main container. Used to start up something like the service that the
    * package represents, like running a bitcoind in a bitcoind-wrapper.
    */
-  export type main = (options: {
+  export type main = (options: { effects: Effects; started(onTerm: () => void): null }) => Promise<unknown>;
-    effects: Effects;
-    started(onTerm: () => void): null;
-  }) => Promise<unknown>;
 
   /**
    * Every time a package completes an install, this function is called before the main.
    * Can be used to do migration like things.
    */
-  export type init = (options: {
+  export type init = (options: { effects: Effects; previousVersion: null | string }) => Promise<unknown>;
-    effects: Effects;
-    previousVersion: null | string;
-  }) => Promise<unknown>;
   /** This will be ran during any time a package is uninstalled, for example during a update
    * this will be called.
    */
-  export type uninit = (options: {
+  export type uninit = (options: { effects: Effects; nextVersion: null | string }) => Promise<unknown>;
-    effects: Effects;
-    nextVersion: null | string;
-  }) => Promise<unknown>;
 }
 export type TimeMs = number;
 export type VersionString = string;
@@ -88,11 +61,7 @@ export type ConfigRes = {
 /** Used to reach out from the pure js runtime */
 export type Effects = {
   /** Usable when not sandboxed */
-  writeFile(input: {
+  writeFile(input: { path: string; volumeId: string; toWrite: string }): Promise<void>;
-    path: string;
-    volumeId: string;
-    toWrite: string;
-  }): Promise<void>;
   readFile(input: { volumeId: string; path: string }): Promise<string>;
   metadata(input: { volumeId: string; path: string }): Promise<Metadata>;
   /** Create a directory. Usable when not sandboxed */
@@ -104,27 +73,13 @@ export type Effects = {
   removeFile(input: { volumeId: string; path: string }): Promise<void>;
 
   /** Write a json file into an object. Usable when not sandboxed */
-  writeJsonFile(input: {
+  writeJsonFile(input: { volumeId: string; path: string; toWrite: Record<string, unknown> }): Promise<void>;
-    volumeId: string;
-    path: string;
-    toWrite: Record<string, unknown>;
-  }): Promise<void>;
 
   /** Read a json file into an object */
-  readJsonFile(input: {
+  readJsonFile(input: { volumeId: string; path: string }): Promise<Record<string, unknown>>;
-    volumeId: string;
-    path: string;
-  }): Promise<Record<string, unknown>>;
 
-  shell(
+  shell(command: string, options?: { timeoutMillis?: number | null }): Promise<string>;
-    command: string,
+  runCommand(input: { command: string; args?: string[]; timeoutMillis?: number }): Promise<string>;
-    options?: { timeoutMillis?: number | null }
-  ): Promise<string>;
-  runCommand(input: {
-    command: string;
-    args?: string[];
-    timeoutMillis?: number;
-  }): Promise<string>;
   runDaemon(input: { command: string; args?: string[] }): {
     wait(): Promise<string>;
     term(): Promise<void>;
@@ -154,17 +109,9 @@ export type Effects = {
   /** Check that a file exists or not */
   exists(input: { volumeId: string; path: string }): Promise<boolean>;
   /** Declaring that we are opening a interface on some protocal for local network */
-  bindLocal(options: {
+  bindLocal(options: { internalPort: number; name: string; externalPort: number }): Promise<string>;
-    internalPort: number;
-    name: string;
-    externalPort: number;
-  }): Promise<string>;
   /** Declaring that we are opening a interface on some protocal for tor network */
-  bindTor(options: {
+  bindTor(options: { internalPort: number; name: string; externalPort: number }): Promise<string>;
-    internalPort: number;
-    name: string;
-    externalPort: number;
-  }): Promise<string>;
 
   /** Similar to the fetch api via the mdn, this is simplified but the point is
    * to get something from some website, and return the response.
@@ -212,22 +159,13 @@ export type Effects = {
   }): Promise<unknown>;
 
   /** Get the address for another service for local internet*/
-  getServiceLocalAddress(options: {
+  getServiceLocalAddress(options: { packageId: string; interfaceName: string }): Promise<string>;
-    packageId: string;
-    interfaceName: string;
-  }): Promise<string>;
   /** Get the address for another service for tor interfaces */
-  getServiceTorAddress(options: {
+  getServiceTorAddress(options: { packageId: string; interfaceName: string }): Promise<string>;
-    packageId: string;
-    interfaceName: string;
-  }): Promise<string>;
   /**
    * Get the port address for another service
    */
-  getServicePortForward(options: {
+  getServicePortForward(options: { packageId: string; internalPort: number }): Promise<string>;
-    packageId: string;
-    internalPort: number;
-  }): Promise<string>;
 
   /** When we want to create a link in the front end interfaces, and example is
    * exposing a url to view a web service
@@ -283,10 +221,7 @@ export type Effects = {
    *
    * @returns  PEM encoded fullchain (ecdsa)
    */
-  getSslCertificate: (
+  getSslCertificate: (packageId: string, algorithm?: "ecdsa" | "ed25519") => [string, string, string];
-    packageId: string,
-    algorithm?: "ecdsa" | "ed25519"
-  ) => [string, string, string];
   /**
    * @returns PEM encoded ssl key (ecdsa)
    */
@@ -414,6 +349,4 @@ export type Dependencies = {
   };
 };
 
-export type DeepPartial<T> = T extends {}
+export type DeepPartial<T> = T extends {} ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
-  ? { [P in keyof T]?: DeepPartial<T[P]> }
-  : T;

lib/util/propertiesMatcher.ts

@@ -3,21 +3,14 @@ import { Parser, Validator } from "ts-matches";
 import { Variants } from "../config/builder";
 import {
   InputSpec,
+  UnionSelectKey,
   unionSelectKey,
+  unionValueKey,
+  UnionValueKey,
   ValueSpec as ValueSpecAny,
-} from "../config/config-types";
+} from "../config/configTypes";
 
-const {
+const { string, some, arrayOf, object, dictionary, unknown, number, literals, boolean } = matches;
-  string,
-  some,
-  arrayOf,
-  object,
-  dictionary,
-  unknown,
-  number,
-  literals,
-  boolean,
-} = matches;
 
 type TypeBoolean = "boolean";
 type TypeString = "string";
@@ -85,7 +78,7 @@ type VariantValue<A> =
 // prettier-ignore
 type GuardUnion<A> =
   A extends {  type: TypeUnion, variants: infer Variants & Record<string, unknown> } ? (
-    _<{[key in keyof Variants]: {unionSelectKey: key} & VariantValue<Variants[key]>}[keyof Variants]>
+    _<{[key in keyof Variants]: {[k in UnionSelectKey]: key} & {[k in UnionValueKey]: VariantValue<Variants[key]>}}[keyof Variants]>
   ) :
   unknown
 
@@ -139,28 +132,18 @@ function charRange(value = "") {
  * @param param1
  * @returns
  */
-export function generateDefault(
+export function generateDefault(generate: { charset: string; len: number }, { random = () => Math.random() } = {}) {
-  generate: { charset: string; len: number },
+  const validCharSets: number[][] = generate.charset.split(",").map(charRange).filter(Array.isArray);
-  { random = () => Math.random() } = {}
-) {
-  const validCharSets: number[][] = generate.charset
-    .split(",")
-    .map(charRange)
-    .filter(Array.isArray);
   if (validCharSets.length === 0) {
     throw new Error("Expecing that we have a valid charset");
   }
-  const max = validCharSets.reduce(
+  const max = validCharSets.reduce((acc, x) => x.reduce((x, y) => Math.max(x, y), acc), 0);
-    (acc, x) => x.reduce((x, y) => Math.max(x, y), acc),
-    0
-  );
   let i = 0;
   const answer: string[] = Array(generate.len);
   while (i < generate.len) {
     const nextValue = Math.round(random() * max);
     const inRange = validCharSets.reduce(
-      (acc, [lower, upper]) =>
+      (acc, [lower, upper]) => acc || (nextValue >= lower && nextValue <= upper),
-        acc || (nextValue >= lower && nextValue <= upper),
       false
     );
     if (!inRange) continue;
@@ -177,16 +160,8 @@ export function matchNumberWithRange(range: string) {
 
   return number
     .validate(
-      leftValue === "*"
+      leftValue === "*" ? (_) => true : left === "[" ? (x) => x >= Number(leftValue) : (x) => x > Number(leftValue),
-        ? (_) => true
+      leftValue === "*" ? "any" : left === "[" ? `greaterThanOrEqualTo${leftValue}` : `greaterThan${leftValue}`
-        : left === "["
-        ? (x) => x >= Number(leftValue)
-        : (x) => x > Number(leftValue),
-      leftValue === "*"
-        ? "any"
-        : left === "["
-        ? `greaterThanOrEqualTo${leftValue}`
-        : `greaterThan${leftValue}`
     )
     .validate(
       // prettier-ignore
@@ -218,9 +193,7 @@ const isGenerator = object({
 function defaultRequired<A>(parser: Parser<unknown, A>, value: unknown) {
   if (matchDefault.test(value)) {
     if (isGenerator(value.default)) {
-      return parser.defaultTo(
+      return parser.defaultTo(parser.unsafeCast(generateDefault(value.default)));
-        parser.unsafeCast(generateDefault(value.default))
-      );
     }
     return parser.defaultTo(value.default);
   }
@@ -236,9 +209,7 @@ function defaultRequired<A>(parser: Parser<unknown, A>, value: unknown) {
  * @param value
  * @returns
  */
-export function guardAll<A extends ValueSpecAny>(
+export function guardAll<A extends ValueSpecAny>(value: A): Parser<unknown, GuardAll<A>> {
-  value: A
-): Parser<unknown, GuardAll<A>> {
   if (!isType.test(value)) {
     return unknown as any;
   }
@@ -253,10 +224,7 @@ export function guardAll<A extends ValueSpecAny>(
       return defaultRequired(string, value) as any;
 
     case "number":
-      return defaultRequired(
+      return defaultRequired(withIntegral(withRange(value), value), value) as any;
-        withIntegral(withRange(value), value),
-        value
-      ) as any;
 
     case "object":
       if (matchSpec.test(value)) {
@@ -266,53 +234,43 @@ export function guardAll<A extends ValueSpecAny>(
 
     case "list": {
       const spec = (matchSpec.test(value) && value.spec) || {};
-      const rangeValidate =
+      const rangeValidate = (matchRange.test(value) && matchNumberWithRange(value.range).test) || (() => true);
-        (matchRange.test(value) && matchNumberWithRange(value.range).test) ||
-        (() => true);
 
       return defaultRequired(
-        matches
+        matches.arrayOf(guardAll(spec as any)).validate((x) => rangeValidate(x.length), "valid length"),
-          .arrayOf(guardAll(spec as any))
-          .validate((x) => rangeValidate(x.length), "valid length"),
         value
       ) as any;
     }
     case "select":
       if (matchValues.test(value)) {
         const valueKeys = Object.keys(value.values);
-        return defaultRequired(
+        return defaultRequired(literals(valueKeys[0], ...valueKeys), value) as any;
-          literals(valueKeys[0], ...valueKeys),
-          value
-        ) as any;
       }
       return unknown as any;
 
     case "multiselect":
       if (matchValues.test(value)) {
-        const maybeAddRangeValidate = <X extends Validator<unknown, B[]>, B>(
+        const maybeAddRangeValidate = <X extends Validator<unknown, B[]>, B>(x: X) => {
-          x: X
-        ) => {
           if (!matchRange.test(value)) return x;
-          return x.validate(
+          return x.validate((x) => matchNumberWithRange(value.range).test(x.length), "validLength");
-            (x) => matchNumberWithRange(value.range).test(x.length),
-            "validLength"
-          );
         };
 
         const valueKeys = Object.keys(value.values);
-        return defaultRequired(
+        return defaultRequired(maybeAddRangeValidate(arrayOf(literals(valueKeys[0], ...valueKeys))), value) as any;
-          maybeAddRangeValidate(arrayOf(literals(valueKeys[0], ...valueKeys))),
-          value
-        ) as any;
       }
       return unknown as any;
 
     case "union":
       if (matchUnion.test(value)) {
         return some(
-          ...Object.entries(value.variants).map(([_, { spec }]) =>
+          ...Object.entries(value.variants)
-            typeFromProps(spec)
+            .filter(([name]) => string.test(name))
-          )
+            .map(([name, { spec }]) =>
+              object({
+                unionSelectKey: literals(name),
+                unionValueKey: typeFromProps(spec),
+              })
+            )
         ) as any;
       }
       return unknown as any;
@@ -328,16 +286,9 @@ export function guardAll<A extends ValueSpecAny>(
  * @param valueDictionary
  * @returns
  */
-export function typeFromProps<A extends InputSpec>(
+export function typeFromProps<A extends InputSpec>(valueDictionary: A): Parser<unknown, TypeFromProps<A>> {
-  valueDictionary: A
-): Parser<unknown, TypeFromProps<A>> {
   if (!recordString.test(valueDictionary)) return unknown as any;
   return object(
-    Object.fromEntries(
+    Object.fromEntries(Object.entries(valueDictionary).map(([key, value]) => [key, guardAll(value)]))
-      Object.entries(valueDictionary).map(([key, value]) => [
-        key,
-        guardAll(value),
-      ])
-    )
   ) as any;
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-sdk",
-  "version": "0.4.0-lib0.beta9",
+  "version": "0.4.0-lib0.charlie1",
   "description": "For making the patterns that are wanted in making services for the startOS.",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

scripts/oldSpecToBuilder.ts

@@ -1,22 +1,17 @@
 import camelCase from "lodash/camelCase";
 import * as fs from "fs";
 import { string } from "ts-matches";
-import { unionSelectKey } from "../lib/config/config-types";
+import { unionSelectKey } from "../lib/config/configTypes";
 
 export async function writeConvertedFile(
   file: string,
   inputData: Promise<any> | any,
   options: Parameters<typeof makeFileContent>[1]
 ) {
-  await fs.writeFile(file, await makeFileContent(inputData, options), (err) =>
+  await fs.writeFile(file, await makeFileContent(inputData, options), (err) => console.error(err));
-    console.error(err)
-  );
 }
 
-export default async function makeFileContent(
+export default async function makeFileContent(inputData: Promise<any> | any, { startSdk = "start-sdk" } = {}) {
-  inputData: Promise<any> | any,
-  { startSdk = "start-sdk" } = {}
-) {
   const outputLines: string[] = [];
   outputLines.push(`
   import {Config, Value, List, Variants} from '${startSdk}/config/builder';
@@ -25,13 +20,8 @@ export default async function makeFileContent(
 
   const namedConsts = new Set(["Config", "Value", "List"]);
   const configName = newConst("InputSpec", convertInputSpec(data));
-  const configMatcherName = newConst(
+  const configMatcherName = newConst("matchInputSpec", `${configName}.validator()`);
-    "matchInputSpec",
+  outputLines.push(`export type InputSpec = typeof ${configMatcherName}._TYPE;`);
-    `${configName}.validator()`
-  );
-  outputLines.push(
-    `export type InputSpec = typeof ${configMatcherName}._TYPE;`
-  );
 
   return outputLines.join("\n");
 
@@ -45,7 +35,7 @@ export default async function makeFileContent(
     for (const [key, value] of Object.entries(data)) {
       const variableName = newConst(key, convertValueSpec(value));
 
-      answer += `"${key}": ${variableName},`;
+      answer += `${JSON.stringify(key)}: ${variableName},`;
     }
     return `${answer}});`;
   }
@@ -111,10 +101,7 @@ export default async function makeFileContent(
         )})`;
       }
       case "enum": {
-        const allValueNames = new Set([
+        const allValueNames = new Set([...(value?.["values"] || []), ...Object.keys(value?.["value-names"] || {})]);
-          ...(value?.["values"] || []),
-          ...Object.keys(value?.["value-names"] || {}),
-        ]);
         const values = Object.fromEntries(
           Array.from(allValueNames)
             .filter(string.test)
@@ -134,10 +121,7 @@ export default async function makeFileContent(
         )} as const)`;
       }
       case "object": {
-        const specName = newConst(
+        const specName = newConst(value.name + "_spec", convertInputSpec(value.spec));
-          value.name + "_spec",
-          convertInputSpec(value.spec)
-        );
         return `Value.object({
         name: ${JSON.stringify(value.name || null)},
         description: ${JSON.stringify(value.description || null)},
@@ -174,9 +158,7 @@ export default async function makeFileContent(
   function convertList(value: any) {
     switch (value.subtype) {
       case "string": {
-        return `List.${
+        return `List.${value?.spec?.textarea === true ? "textarea" : "string"}(${JSON.stringify(
-          value?.spec?.textarea === true ? "textarea" : "string"
-        }(${JSON.stringify(
           {
             name: value.name || null,
             range: value.range || null,
@@ -235,10 +217,7 @@ export default async function makeFileContent(
         )})`;
       }
       case "object": {
-        const specName = newConst(
+        const specName = newConst(value.name + "_spec", convertInputSpec(value.spec.spec));
-          value.name + "_spec",
-          convertInputSpec(value.spec.spec)
-        );
         return `List.obj({
           name: ${JSON.stringify(value.name || null)},
           range: ${JSON.stringify(value.range || null)},
@@ -254,19 +233,14 @@ export default async function makeFileContent(
       case "union": {
         const variants = newConst(
           value.name + "_variants",
-          convertVariants(
+          convertVariants(value.spec.variants, value.spec["variant-names"] || {})
-            value.spec.variants,
-            value.spec["variant-names"] || {}
-          )
         );
         const unionValueName = newConst(
           value.name + "_union",
           `
           Value.union({
             name: ${JSON.stringify(value?.spec?.tag?.name || null)},
-            description: ${JSON.stringify(
+            description: ${JSON.stringify(value?.spec?.tag?.description || null)},
-              value?.spec?.tag?.description || null
-            )},
             warning: ${JSON.stringify(value?.spec?.tag?.warning || null)},
             required: ${JSON.stringify(!(value?.spec?.tag?.nullable || false))},
             default: ${JSON.stringify(value?.spec?.default || null)},
@@ -277,7 +251,7 @@ export default async function makeFileContent(
           value.name + "_list_config",
           `
           Config.of({
-            ${unionSelectKey}: ${unionValueName}
+            "union": ${unionValueName}
           })
         `
         );
@@ -297,16 +271,11 @@ export default async function makeFileContent(
     throw new Error(`Unknown subtype "${value.subtype}"`);
   }
 
-  function convertVariants(
+  function convertVariants(variants: Record<string, unknown>, variantNames: Record<string, string>): string {
-    variants: Record<string, unknown>,
-    variantNames: Record<string, string>
-  ): string {
     let answer = "Variants.of({";
     for (const [key, value] of Object.entries(variants)) {
       const variantSpec = newConst(key, convertInputSpec(value));
-      answer += `"${key}": {name: "${
+      answer += `"${key}": {name: "${variantNames[key] || key}", spec: ${variantSpec}},`;
-        variantNames[key] || key
-      }", spec: ${variantSpec}},`;
     }
     return `${answer}})`;
   }