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

package/lib/actions/createAction.ts

@@ -1,88 +0,0 @@
-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

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

package/lib/actions/setupActions.ts

@@ -1,29 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

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

package/lib/backup/setupBackups.ts

@@ -1,43 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

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