feat: add autoConfig/ better types for wrapperData

lib/util/index.ts

@@ -5,20 +5,23 @@ import nullIfEmpty from "./nullIfEmpty";
 import { getWrapperData } from "./getWrapperData";
 import { checkPortListening, checkWebUrl } from "../health/checkFns";
 import { LocalPort, NetworkBuilder, TorHostname } from "../mainFn";
+import { ExtractWrapperData } from "../types";
 
 export { guardAll, typeFromProps } from "./propertiesMatcher";
 export { default as nullIfEmpty } from "./nullIfEmpty";
 export { FileHelper } from "./fileHelper";
 export { getWrapperData } from "./getWrapperData";
+export { deepEqual } from "./deepEqual";
+export { deepMerge } from "./deepMerge";
 
 /** Used to check if the file exists before hand */
 export const exists = (
   effects: T.Effects,
-  props: { path: string; volumeId: string }
+  props: { path: string; volumeId: string },
 ) =>
   effects.metadata(props).then(
     (_) => true,
-    (_) => false
+    (_) => false,
   );
 
 export const isKnownError = (e: unknown): e is T.KnownError =>
@@ -26,28 +29,40 @@ export const isKnownError = (e: unknown): e is T.KnownError =>
 
 type Cdr<A> = A extends [unknown, ...infer Cdr] ? Cdr : [];
 
-export const utils = (effects: T.Effects) => ({
+declare const affine: unique symbol;
+
+function withAffine<B>() {
+  return {} as { [affine]: B };
+}
+
+export const utils = <WrapperData = never>(effects: T.Effects) => ({
   readFile: <A>(fileHelper: FileHelper<A>) => fileHelper.read(effects),
   writeFile: <A>(fileHelper: FileHelper<A>, data: A) =>
     fileHelper.write(data, effects),
   exists: (props: { path: string; volumeId: string }) => exists(effects, props),
   nullIfEmpty,
-  getWrapperData: <A>(
-    validator: Parser<unknown, A>,
+  getWrapperData: <Path extends string>(
+    path: T.EnsureWrapperDataPath<WrapperData, Path>,
     options: {
+      validator?: Parser<unknown, ExtractWrapperData<WrapperData, Path>>;
       /** Defaults to what ever the package currently in */
       packageId?: string | undefined;
-      /** JsonPath */
-      path?: string | undefined;
-    } = {}
-  ) => getWrapperData(effects, validator, options),
-  setWrapperData: <A>(
-    value: A,
-    options: { packageId?: string | undefined; path?: string | undefined } = {}
-  ) => effects.setWrapperData({ ...options, value }),
+    } = {},
+  ) => getWrapperData<WrapperData, Path>(effects, path as any, options),
+  setWrapperData: <Path extends string | never>(
+    path: T.EnsureWrapperDataPath<WrapperData, Path>,
+    value: ExtractWrapperData<WrapperData, Path>,
+  ) => effects.setWrapperData<WrapperData, Path>({ value, path: path as any }),
   checkPortListening: checkPortListening.bind(null, effects),
   checkWebUrl: checkWebUrl.bind(null, effects),
   localPort: LocalPort.bind(null, effects),
   networkBuilder: NetworkBuilder.of.bind(null, effects),
   torHostName: TorHostname.of.bind(null, effects),
 });
+
+type NeverPossible = { [affine]: string };
+export type NoAny<A> = NeverPossible extends A
+  ? keyof NeverPossible extends keyof A
+    ? never
+    : A
+  : A;