@start9labs/start-sdk 0.3.6-alpha1 → 0.3.6-alpha2

package/lib/actions/createAction.ts

@@ -0,0 +1,88 @@
+import { Config, ExtractConfigType } from "../config/builder/config"
+import { SDKManifest } from "../manifest/ManifestTypes"
+import { ActionMetadata, ActionResult, Effects, ExportedAction } from "../types"
+
+export type MaybeFn<Manifest extends SDKManifest, Store, Value> =
+  | Value
+  | ((options: { effects: Effects }) => Promise<Value> | Value)
+export class CreatedAction<
+  Manifest extends SDKManifest,
+  Store,
+  ConfigType extends
+    | Record<string, any>
+    | Config<any, Store>
+    | Config<any, never>,
+  Type extends Record<string, any> = ExtractConfigType<ConfigType>,
+> {
+  private constructor(
+    public readonly id: string,
+    public readonly myMetadata: MaybeFn<
+      Manifest,
+      Store,
+      Omit<ActionMetadata, "input">
+    >,
+    readonly fn: (options: {
+      effects: Effects
+      input: Type
+    }) => Promise<ActionResult>,
+    readonly input: Config<Type, Store>,
+    public validator = input.validator,
+  ) {}
+
+  static of<
+    Manifest extends SDKManifest,
+    Store,
+    ConfigType extends
+      | Record<string, any>
+      | Config<any, any>
+      | Config<any, never>,
+    Type extends Record<string, any> = ExtractConfigType<ConfigType>,
+  >(
+    id: string,
+    metadata: MaybeFn<Manifest, Store, Omit<ActionMetadata, "input">>,
+    fn: (options: { effects: Effects; input: Type }) => Promise<ActionResult>,
+    inputConfig: Config<Type, Store> | Config<Type, never>,
+  ) {
+    return new CreatedAction<Manifest, Store, ConfigType, Type>(
+      id,
+      metadata,
+      fn,
+      inputConfig as Config<Type, Store>,
+    )
+  }
+
+  exportedAction: ExportedAction = ({ effects, input }) => {
+    return this.fn({
+      effects,
+      input: this.validator.unsafeCast(input),
+    })
+  }
+
+  run = async ({ effects, input }: { effects: Effects; input?: Type }) => {
+    return this.fn({
+      effects,
+      input: this.validator.unsafeCast(input),
+    })
+  }
+
+  async metadata(options: { effects: Effects }) {
+    if (this.myMetadata instanceof Function)
+      return await this.myMetadata(options)
+    return this.myMetadata
+  }
+
+  async ActionMetadata(options: { effects: Effects }): Promise<ActionMetadata> {
+    return {
+      ...(await this.metadata(options)),
+      input: await this.input.build(options),
+    }
+  }
+
+  async getConfig({ effects }: { effects: Effects }) {
+    return this.input.build({
+      effects,
+    })
+  }
+}
+
+export const createAction = CreatedAction.of

package/lib/actions/index.ts

@@ -0,0 +1,3 @@
+import "./createAction"
+
+import "./setupActions"

package/lib/actions/setupActions.ts

@@ -0,0 +1,29 @@
+import { SDKManifest } from "../manifest/ManifestTypes"
+import { Effects, ExpectedExports } from "../types"
+import { CreatedAction } from "./createAction"
+
+export function setupActions<Manifest extends SDKManifest, Store>(
+  ...createdActions: CreatedAction<Manifest, Store, any>[]
+) {
+  const myActions = async (options: { effects: Effects }) => {
+    const actions: Record<string, CreatedAction<Manifest, Store, any>> = {}
+    for (const action of createdActions) {
+      actions[action.id] = action
+    }
+    return actions
+  }
+  const answer: {
+    actions: ExpectedExports.actions
+    actionsMetadata: ExpectedExports.actionsMetadata
+  } = {
+    actions(options: { effects: Effects }) {
+      return myActions(options)
+    },
+    async actionsMetadata({ effects }: { effects: Effects }) {
+      return Promise.all(
+        createdActions.map((x) => x.ActionMetadata({ effects })),
+      )
+    },
+  }
+  return answer
+}

package/lib/backup/Backups.ts

@@ -0,0 +1,181 @@
+import { SDKManifest } from "../manifest/ManifestTypes"
+import * as T from "../types"
+
+export type BACKUP = "BACKUP"
+export const DEFAULT_OPTIONS: T.BackupOptions = {
+  delete: true,
+  force: true,
+  ignoreExisting: false,
+  exclude: [],
+}
+export type BackupSet<Volumes extends string> = {
+  srcPath: string
+  srcVolume: Volumes | BACKUP
+  dstPath: string
+  dstVolume: Volumes | BACKUP
+  options?: Partial<T.BackupOptions>
+}
+/**
+ * This utility simplifies the volume backup process.
+ * ```ts
+ * export const { createBackup, restoreBackup } = Backups.volumes("main").build();
+ * ```
+ *
+ * Changing the options of the rsync, (ie exludes) use either
+ * ```ts
+ *  Backups.volumes("main").set_options({exclude: ['bigdata/']}).volumes('excludedVolume').build()
+ * // or
+ *  Backups.with_options({exclude: ['bigdata/']}).volumes('excludedVolume').build()
+ * ```
+ *
+ * Using the more fine control, using the addSets for more control
+ * ```ts
+ * Backups.addSets({
+ * srcVolume: 'main', srcPath:'smallData/', dstPath: 'main/smallData/', dstVolume: : Backups.BACKUP
+ * }, {
+ * srcVolume: 'main', srcPath:'bigData/', dstPath: 'main/bigData/', dstVolume: : Backups.BACKUP, options: {exclude:['bigData/excludeThis']}}
+ * ).build()q
+ * ```
+ */
+export class Backups<M extends SDKManifest> {
+  static BACKUP: BACKUP = "BACKUP"
+
+  private constructor(
+    private options = DEFAULT_OPTIONS,
+    private backupSet = [] as BackupSet<M["volumes"][number]>[],
+  ) {}
+  static volumes<M extends SDKManifest = never>(
+    ...volumeNames: Array<M["volumes"][0]>
+  ): Backups<M> {
+    return new Backups<M>().addSets(
+      ...volumeNames.map((srcVolume) => ({
+        srcVolume,
+        srcPath: "./",
+        dstPath: `./${srcVolume}/`,
+        dstVolume: Backups.BACKUP,
+      })),
+    )
+  }
+  static addSets<M extends SDKManifest = never>(
+    ...options: BackupSet<M["volumes"][0]>[]
+  ) {
+    return new Backups().addSets(...options)
+  }
+  static with_options<M extends SDKManifest = never>(
+    options?: Partial<T.BackupOptions>,
+  ) {
+    return new Backups({ ...DEFAULT_OPTIONS, ...options })
+  }
+
+  static withOptions = Backups.with_options
+  setOptions(options?: Partial<T.BackupOptions>) {
+    this.options = {
+      ...this.options,
+      ...options,
+    }
+    return this
+  }
+  volumes(...volumeNames: Array<M["volumes"][0]>) {
+    return this.addSets(
+      ...volumeNames.map((srcVolume) => ({
+        srcVolume,
+        srcPath: "./",
+        dstPath: `./${srcVolume}/`,
+        dstVolume: Backups.BACKUP,
+      })),
+    )
+  }
+  addSets(...options: BackupSet<M["volumes"][0]>[]) {
+    options.forEach((x) =>
+      this.backupSet.push({ ...x, options: { ...this.options, ...x.options } }),
+    )
+    return this
+  }
+  build() {
+    const createBackup: T.ExpectedExports.createBackup = async ({
+      effects,
+    }) => {
+      // const previousItems = (
+      //   await effects
+      //     .readDir({
+      //       volumeId: Backups.BACKUP,
+      //       path: ".",
+      //     })
+      //     .catch(() => [])
+      // ).map((x) => `${x}`)
+      // const backupPaths = this.backupSet
+      //   .filter((x) => x.dstVolume === Backups.BACKUP)
+      //   .map((x) => x.dstPath)
+      //   .map((x) => x.replace(/\.\/([^]*)\//, "$1"))
+      // const filteredItems = previousItems.filter(
+      //   (x) => backupPaths.indexOf(x) === -1,
+      // )
+      // for (const itemToRemove of filteredItems) {
+      //   effects.console.error(`Trying to remove ${itemToRemove}`)
+      //   await effects
+      //     .removeDir({
+      //       volumeId: Backups.BACKUP,
+      //       path: itemToRemove,
+      //     })
+      //     .catch(() =>
+      //       effects.removeFile({
+      //         volumeId: Backups.BACKUP,
+      //         path: itemToRemove,
+      //       }),
+      //     )
+      //     .catch(() => {
+      //       console.warn(`Failed to remove ${itemToRemove} from backup volume`)
+      //     })
+      // }
+      for (const item of this.backupSet) {
+        // if (notEmptyPath(item.dstPath)) {
+        //   await effects.createDir({
+        //     volumeId: item.dstVolume,
+        //     path: item.dstPath,
+        //   })
+        // }
+        // await effects
+        //   .runRsync({
+        //     ...item,
+        //     options: {
+        //       ...this.options,
+        //       ...item.options,
+        //     },
+        //   })
+        //   .wait()
+      }
+      return
+    }
+    const restoreBackup: T.ExpectedExports.restoreBackup = async ({
+      effects,
+    }) => {
+      for (const item of this.backupSet) {
+        // if (notEmptyPath(item.srcPath)) {
+        //   await new Promise((resolve, reject) => fs.mkdir(items.src)).createDir(
+        //     {
+        //       volumeId: item.srcVolume,
+        //       path: item.srcPath,
+        //     },
+        //   )
+        // }
+        // await effects
+        //   .runRsync({
+        //     options: {
+        //       ...this.options,
+        //       ...item.options,
+        //     },
+        //     srcVolume: item.dstVolume,
+        //     dstVolume: item.srcVolume,
+        //     srcPath: item.dstPath,
+        //     dstPath: item.srcPath,
+        //   })
+        //   .wait()
+      }
+      return
+    }
+    return { createBackup, restoreBackup }
+  }
+}
+function notEmptyPath(file: string) {
+  return ["", ".", "./"].indexOf(file) === -1
+}

package/lib/backup/index.ts

@@ -0,0 +1,3 @@
+import "./Backups"
+
+import "./setupBackups"

package/lib/backup/setupBackups.ts

@@ -0,0 +1,43 @@
+import { Backups } from "./Backups"
+import { SDKManifest } from "../manifest/ManifestTypes"
+import { ExpectedExports } from "../types"
+import { _ } from "../util"
+
+export type SetupBackupsParams<M extends SDKManifest> = Array<
+  M["volumes"][number] | Backups<M>
+>
+
+export function setupBackups<M extends SDKManifest>(
+  ...args: _<SetupBackupsParams<M>>
+) {
+  const backups = Array<Backups<M>>()
+  const volumes = new Set<M["volumes"][0]>()
+  for (const arg of args) {
+    if (arg instanceof Backups) {
+      backups.push(arg)
+    } else {
+      volumes.add(arg)
+    }
+  }
+  backups.push(Backups.volumes(...volumes))
+  const answer: {
+    createBackup: ExpectedExports.createBackup
+    restoreBackup: ExpectedExports.restoreBackup
+  } = {
+    get createBackup() {
+      return (async (options) => {
+        for (const backup of backups) {
+          await backup.build().createBackup(options)
+        }
+      }) as ExpectedExports.createBackup
+    },
+    get restoreBackup() {
+      return (async (options) => {
+        for (const backup of backups) {
+          await backup.build().restoreBackup(options)
+        }
+      }) as ExpectedExports.restoreBackup
+    },
+  }
+  return answer
+}

package/lib/config/builder/config.ts

@@ -0,0 +1,137 @@
+import { ValueSpec } from "../configTypes"
+import { Value } from "./value"
+import { _ } from "../../util"
+import { Effects } from "../../types"
+import { Parser, object } from "ts-matches"
+
+export type LazyBuildOptions<Store> = {
+  effects: Effects
+}
+export type LazyBuild<Store, ExpectedOut> = (
+  options: LazyBuildOptions<Store>,
+) => Promise<ExpectedOut> | ExpectedOut
+
+// prettier-ignore
+export type ExtractConfigType<A extends Record<string, any> | Config<Record<string, any>, any> | Config<Record<string, any>, never>> = 
+  A extends Config<infer B, any> | Config<infer B, never> ? B :
+  A
+
+export type ConfigSpecOf<A extends Record<string, any>, Store = never> = {
+  [K in keyof A]: Value<A[K], Store>
+}
+
+export type MaybeLazyValues<A> = LazyBuild<any, A> | A
+/**
+ * Configs are the specs that are used by the os configuration form for this service.
+ * Here is an example of a simple configuration
+  ```ts
+    const smallConfig = Config.of({
+      test: Value.boolean({
+        name: "Test",
+        description: "This is the description for the test",
+        warning: null,
+        default: false,
+      }),
+    });
+  ```
+
+  The idea of a config is that now the form is going to ask for
+  Test: [ ] and the value is going to be checked as a boolean.
+  There are more complex values like selects, lists, and objects. See {@link Value}
+
+  Also, there is the ability to get a validator/parser from this config spec.
+  ```ts
+  const matchSmallConfig = smallConfig.validator();
+  type SmallConfig = typeof matchSmallConfig._TYPE;
+  ```
+
+  Here is an example of a more complex configuration which came from a configuration for a service
+  that works with bitcoin, like c-lightning.
+  ```ts
+
+    export const hostname = Value.string({
+  name: "Hostname",
+  default: null,
+  description: "Domain or IP address of bitcoin peer",
+  warning: null,
+  required: true,
+  masked: false,
+  placeholder: null,
+  pattern:
+    "(^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$)|((^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$)|(^[a-z2-7]{16}\\.onion$)|(^([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$))",
+  patternDescription:
+    "Must be either a domain name, or an IPv4 or IPv6 address. Do not include protocol scheme (eg 'http://') or port.",
+});
+export const port = Value.number({
+  name: "Port",
+  default: null,
+  description: "Port that peer is listening on for inbound p2p connections",
+  warning: null,
+  required: false,
+  range: "[0,65535]",
+  integral: true,
+  units: null,
+  placeholder: null,
+});
+export const addNodesSpec = Config.of({ hostname: hostname, port: port });
+
+  ```
+ */
+export class Config<Type extends Record<string, any>, Store = never> {
+  private constructor(
+    private readonly spec: {
+      [K in keyof Type]: Value<Type[K], Store> | Value<Type[K], never>
+    },
+    public validator: Parser<unknown, Type>,
+  ) {}
+  async build(options: LazyBuildOptions<Store>) {
+    const answer = {} as {
+      [K in keyof Type]: ValueSpec
+    }
+    for (const k in this.spec) {
+      answer[k] = await this.spec[k].build(options as any)
+    }
+    return answer
+  }
+
+  static of<
+    Spec extends Record<string, Value<any, Store> | Value<any, never>>,
+    Store = never,
+  >(spec: Spec) {
+    const validatorObj = {} as {
+      [K in keyof Spec]: Parser<unknown, any>
+    }
+    for (const key in spec) {
+      validatorObj[key] = spec[key].validator
+    }
+    const validator = object(validatorObj)
+    return new Config<
+      {
+        [K in keyof Spec]: Spec[K] extends
+          | Value<infer T, Store>
+          | Value<infer T, never>
+          ? T
+          : never
+      },
+      Store
+    >(spec, validator as any)
+  }
+
+  /**
+   * Use this during the times that the input needs a more specific type.
+   * Used in types that the value/ variant/ list/ config is constructed somewhere else.
+  ```ts
+  const a = Config.text({
+    name: "a",
+    required: false,
+  })
+
+  return Config.of<Store>()({
+    myValue: a.withStore(),
+  })
+  ```
+   */
+  withStore<NewStore extends Store extends never ? any : Store>() {
+    return this as any as Config<Type, NewStore>
+  }
+}

package/lib/config/builder/index.ts

@@ -0,0 +1,6 @@
+import { Config } from "./config"
+import { List } from "./list"
+import { Value } from "./value"
+import { Variants } from "./variants"
+
+export { Config, List, Value, Variants }