more utility functions

compat/migrations.ts

@@ -0,0 +1,121 @@
+import { getConfig, setConfig } from "./mod.ts";
+import * as T from "../types.ts";
+import * as M from "../migrations.ts";
+import * as util from "../util.ts";
+import { EmVer } from "../emver-lite/mod.ts";
+
+export interface NoRepeat<version extends string, type extends "up" | "down"> {
+  version: version;
+  type: type;
+}
+
+/**
+ * @param fn function making desired modifications to the config
+ * @param configured whether or not the service should be considered "configured"
+ * @param noRepeat (optional) supply the version and type of the migration
+ * @param noFail (optional, default:false) whether or not to fail the migration if fn throws an error
+ * @returns a migraion function
+ */
+export function updateConfig<
+  version extends string,
+  type extends "up" | "down",
+>(
+  fn: (config: T.Config) => T.Config,
+  configured: boolean,
+  noRepeat?: NoRepeat<version, type>,
+  noFail = false,
+): M.MigrationFn<version, type> {
+  return async (effects: T.Effects) => {
+    await noRepeatGuard(effects, noRepeat, async () => {
+      let config = util.unwrapResultType(await getConfig({})(effects)).config;
+      if (config) {
+        try {
+          config = fn(config);
+        } catch (e) {
+          if (!noFail) {
+            throw e;
+          } else {
+            configured = false;
+          }
+        }
+        util.unwrapResultType(await setConfig(effects, config));
+      }
+    });
+    return { configured };
+  };
+}
+
+export async function noRepeatGuard<
+  version extends string,
+  type extends "up" | "down",
+>(
+  effects: T.Effects,
+  noRepeat: NoRepeat<version, type> | undefined,
+  fn: () => Promise<void>,
+): Promise<void> {
+  if (!noRepeat) {
+    return fn();
+  }
+  if (
+    !await util.exists(effects, { path: "start9/migrations", volumeId: "main" })
+  ) {
+    await effects.createDir({ path: "start9/migrations", volumeId: "main" });
+  }
+  const migrationPath = {
+    path: `start9/migrations/${noRepeat.version}.complete`,
+    volumeId: "main",
+  };
+  if (noRepeat.type === "up") {
+    if (!await util.exists(effects, migrationPath)) {
+      await fn();
+      await effects.writeFile({ ...migrationPath, toWrite: "" });
+    }
+  } else if (noRepeat.type === "down") {
+    if (await util.exists(effects, migrationPath)) {
+      await fn();
+      await effects.removeFile(migrationPath);
+    }
+  }
+}
+
+export async function initNoRepeat<versions extends string>(
+  effects: T.Effects,
+  migrations: M.MigrationMapping<versions>,
+  startingVersion: string,
+) {
+  if (
+    !await util.exists(effects, { path: "start9/migrations", volumeId: "main" })
+  ) {
+    const starting = EmVer.parse(startingVersion);
+    await effects.createDir({ path: "start9/migrations", volumeId: "main" });
+    for (const version in migrations) {
+      const migrationVersion = EmVer.parse(version);
+      if (migrationVersion.lessThanOrEqual(starting)) {
+        await effects.writeFile({
+          path: `start9/migrations/${version}.complete`,
+          volumeId: "main",
+          toWrite: "",
+        });
+      }
+    }
+  }
+}
+
+export function fromMapping<versions extends string>(
+  migrations: M.MigrationMapping<versions>,
+  currentVersion: string,
+): T.ExpectedExports.migration {
+  const inner = M.fromMapping(migrations, currentVersion);
+  return async (
+    effects: T.Effects,
+    version: string,
+    direction?: unknown,
+  ) => {
+    await initNoRepeat(
+      effects,
+      migrations,
+      direction === "from" ? version : currentVersion,
+    );
+    return inner(effects, version, direction);
+  };
+}

compat/mod.ts

@@ -1,3 +1,4 @@
 export { properties } from "./properties.ts";
 export { setConfig } from "./setConfig.ts";
 export { getConfig } from "./getConfig.ts";
+export * as migrations from "./migrations.ts";

compat/properties.ts

@@ -1,10 +1,9 @@
 import { YAML } from "../dependencies.ts";
-import { exists } from "../exists.ts";
+import { exists } from "../util.ts";
-import { ResultType, Properties, ExpectedExports, Effects } from "../types.ts";
+import { Effects, ExpectedExports, Properties, ResultType } from "../types.ts";
-
 
 // deno-lint-ignore no-explicit-any
-const asResult = (result: any) => ({ result: result as Properties })
+const asResult = (result: any) => ({ result: result as Properties });
 const noPropertiesFound: ResultType<Properties> = {
   result: {
     version: 2,
@@ -15,11 +14,11 @@ const noPropertiesFound: ResultType<Properties> = {
         qr: false,
         copyable: false,
         masked: false,
-                description: "Fallback Message When Properties could not be found"
+        description: "Fallback Message When Properties could not be found",
-            }
+      },
-        }
+    },
-    }
+  },
-} as const
+} as const;
 /**
  * Default will pull from a file (start9/stats.yaml) expected to be made on the main volume
  * @param effects
@@ -28,11 +27,14 @@ const noPropertiesFound: ResultType<Properties> = {
 export const properties: ExpectedExports.properties = async (
   effects: Effects,
 ) => {
-    if (await exists(effects, { path: "start9/stats.yaml", volumeId: "main" }) === false) {
+  if (
+    await exists(effects, { path: "start9/stats.yaml", volumeId: "main" }) ===
+      false
+  ) {
     return noPropertiesFound;
   }
   return await effects.readFile({
     path: "start9/stats.yaml",
     volumeId: "main",
-    }).then(YAML.parse).then(asResult)
+  }).then(YAML.parse).then(asResult);
 };

exists.ts

@@ -1,4 +0,0 @@
-import { Effects } from "./types.ts";
-
-/** Used to check if the file exists before hand */
-export const exists = (effects: Effects, props: { path: string, volumeId: string }) => effects.metadata(props).then(_ => true, _ => false);

migrations.ts

@@ -2,19 +2,21 @@ import { types as T } from "./mod.ts";
 import { EmVer } from "./emver-lite/mod.ts";
 import { matches } from "./dependencies.ts";
 
-export type MigrationFn = (effects: T.Effects) => Promise<T.MigrationRes>;
+export type MigrationFn<version extends string, type extends "up" | "down"> = (
+  effects: T.Effects,
+) => Promise<T.MigrationRes>;
 
-export interface Migration {
+export interface Migration<version extends string> {
-  up: MigrationFn;
+  up: MigrationFn<version, "up">;
-  down: MigrationFn;
+  down: MigrationFn<version, "down">;
 }
 
-export interface MigrationMapping {
+export type MigrationMapping<versions extends string> = {
-  [version: string]: Migration;
+  [version in versions]: Migration<version>;
-}
+};
 
-export function fromMapping(
+export function fromMapping<versions extends string>(
-  migrations: MigrationMapping,
+  migrations: MigrationMapping<versions>,
   currentVersion: string,
 ): T.ExpectedExports.migration {
   const directionShape = matches.literals("from", "to");
@@ -32,24 +34,26 @@ export function fromMapping(
     const current = EmVer.parse(currentVersion);
     const other = EmVer.parse(version);
 
-    const migrationsToRun = matches.matches(direction)
+    const filteredMigrations =
-      .when("from", () =>
+      (Object.entries(migrations) as [
-        Object.entries(migrations)
+        keyof MigrationMapping<string>,
+        Migration<string>,
+      ][])
         .map(([version, migration]) => ({
           version: EmVer.parse(version),
           migration,
         })).filter(({ version }) =>
           version.greaterThan(other) && version.lessThanOrEqual(current)
-          ).sort((a, b) => a.version.compareForSort(b.version))
+        );
+
+    const migrationsToRun = matches.matches(direction)
+      .when("from", () =>
+        filteredMigrations
+          .sort((a, b) => a.version.compareForSort(b.version)) // low to high
           .map(({ migration }) => migration.up))
       .when("to", () =>
-        Object.entries(migrations)
+        filteredMigrations
-          .map(([version, migration]) => ({
+          .sort((a, b) => b.version.compareForSort(a.version)) // high to low
-            version: EmVer.parse(version),
-            migration,
-          })).filter(({ version }) =>
-            version.lessThanOrEqual(other) && version.greaterThan(current)
-          ).sort((a, b) => b.version.compareForSort(a.version))
           .map(({ migration }) => migration.down))
       .unwrap();
 

mod.ts

@@ -1,6 +1,6 @@
 export { matches, YAML } from "./dependencies.ts";
 export * as types from "./types.ts";
 
-export { exists } from "./exists.ts";
 export * as compat from "./compat/mod.ts";
 export * as migrations from "./migrations.ts";
+export * as util from "./util.ts";

types.ts

@@ -24,6 +24,7 @@ export namespace ExpectedExports {
   export type migration = (
     effects: Effects,
     version: string,
+    ...args: unknown[]
   ) => Promise<ResultType<MigrationRes>>;
   export type action = {
     [id: string]: (
@@ -143,7 +144,6 @@ export type WithNullableDefault<T, Default> = T & {
   default?: Default;
 };
 
-
 export type WithDescription<T> = T & {
   description?: string;
   name: string;
@@ -213,7 +213,9 @@ export type ValueSpecAny =
   | Tag<"boolean", WithDescription<WithDefault<ValueSpecBoolean, boolean>>>
   | Tag<
     "string",
-    WithDescription<WithNullableDefault<WithNullable<ValueSpecString>, DefaultString>>
+    WithDescription<
+      WithNullableDefault<WithNullable<ValueSpecString>, DefaultString>
+    >
   >
   | Tag<
     "number",

util.ts

@@ -0,0 +1,17 @@
+import * as T from "./types.ts";
+
+export function unwrapResultType<T>(res: T.ResultType<T>): T {
+  if ("error-code" in res) {
+    throw new Error(res["error-code"][1]);
+  } else if ("error" in res) {
+    throw new Error(res["error"]);
+  } else {
+    return res.result;
+  }
+}
+
+/** Used to check if the file exists before hand */
+export const exists = (
+  effects: T.Effects,
+  props: { path: string; volumeId: string },
+) => effects.metadata(props).then((_) => true, (_) => false);