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

package/lib/config/builder/variants.ts

@@ -1,120 +0,0 @@
-import { InputSpec, ValueSpecUnion } from "../configTypes"
-import { LazyBuild, Config } from "./config"
-import { Parser, anyOf, literals, object } from "ts-matches"
-
-/**
- * Used in the the Value.select { @link './value.ts' }
- * to indicate the type of select variants that are available. The key for the record passed in will be the
- * key to the tag.id in the Value.select
-```ts
- 
-export const disabled = Config.of({});
-export const size = Value.number({
-  name: "Max Chain Size",
-  default: 550,
-  description: "Limit of blockchain size on disk.",
-  warning: "Increasing this value will require re-syncing your node.",
-  required: true,
-  range: "[550,1000000)",
-  integral: true,
-  units: "MiB",
-  placeholder: null,
-});
-export const automatic = Config.of({ size: size });
-export const size1 = Value.number({
-  name: "Failsafe Chain Size",
-  default: 65536,
-  description: "Prune blockchain if size expands beyond this.",
-  warning: null,
-  required: true,
-  range: "[550,1000000)",
-  integral: true,
-  units: "MiB",
-  placeholder: null,
-});
-export const manual = Config.of({ size: size1 });
-export const pruningSettingsVariants = Variants.of({
-  disabled: { name: "Disabled", spec: disabled },
-  automatic: { name: "Automatic", spec: automatic },
-  manual: { name: "Manual", spec: manual },
-});
-export const pruning = Value.union(
-  {
-    name: "Pruning Settings",
-    description:
-      '- Disabled: Disable pruning\n- Automatic: Limit blockchain size on disk to a certain number of megabytes\n- Manual: Prune blockchain with the "pruneblockchain" RPC\n',
-    warning: null,
-    required: true,
-    default: "disabled",
-  },
-  pruningSettingsVariants
-);
-```
- */
-export class Variants<Type, Store> {
-  static text: any
-  private constructor(
-    public build: LazyBuild<Store, ValueSpecUnion["variants"]>,
-    public validator: Parser<unknown, Type>,
-  ) {}
-  static of<
-    VariantValues extends {
-      [K in string]: {
-        name: string
-        spec: Config<any, Store> | Config<any, never>
-      }
-    },
-    Store = never,
-  >(a: VariantValues) {
-    const validator = anyOf(
-      ...Object.entries(a).map(([name, { spec }]) =>
-        object({
-          unionSelectKey: literals(name),
-          unionValueKey: spec.validator,
-        }),
-      ),
-    ) as Parser<unknown, any>
-
-    return new Variants<
-      {
-        [K in keyof VariantValues]: {
-          unionSelectKey: K
-          // prettier-ignore
-          unionValueKey: 
-            VariantValues[K]["spec"] extends (Config<infer B, Store> | Config<infer B, never>) ? B :
-            never
-        }
-      }[keyof VariantValues],
-      Store
-    >(async (options) => {
-      const variants = {} as {
-        [K in keyof VariantValues]: { name: string; spec: InputSpec }
-      }
-      for (const key in a) {
-        const value = a[key]
-        variants[key] = {
-          name: value.name,
-          spec: await value.spec.build(options as any),
-        }
-      }
-      return variants
-    }, validator)
-  }
-  /**
-   * 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 Variants<Type, NewStore>
-  }
-}

package/lib/config/configConstants.ts

@@ -1,81 +0,0 @@
-import { SmtpValue } from "../types"
-import { GetSystemSmtp } from "../util/GetSystemSmtp"
-import { email } from "../util/patterns"
-import { Config, ConfigSpecOf } from "./builder/config"
-import { Value } from "./builder/value"
-import { Variants } from "./builder/variants"
-
-/**
- * Base SMTP settings, to be used by StartOS for system wide SMTP
- */
-export const customSmtp = Config.of<ConfigSpecOf<SmtpValue>, never>({
-  server: Value.text({
-    name: "SMTP Server",
-    required: {
-      default: null,
-    },
-  }),
-  port: Value.number({
-    name: "Port",
-    required: { default: 587 },
-    min: 1,
-    max: 65535,
-    integer: true,
-  }),
-  from: Value.text({
-    name: "From Address",
-    required: {
-      default: null,
-    },
-    placeholder: "<name>test@example.com",
-    inputmode: "email",
-    patterns: [email],
-  }),
-  login: Value.text({
-    name: "Login",
-    required: {
-      default: null,
-    },
-  }),
-  password: Value.text({
-    name: "Password",
-    required: false,
-    masked: true,
-  }),
-})
-
-/**
- * For service config. Gives users 3 options for SMTP: (1) disabled, (2) use system SMTP settings, (3) use custom SMTP settings
- */
-export const smtpConfig = Value.filteredUnion(
-  async ({ effects }) => {
-    const smtp = await new GetSystemSmtp(effects).once()
-    return smtp ? [] : ["system"]
-  },
-  {
-    name: "SMTP",
-    description: "Optionally provide an SMTP server for sending emails",
-    required: { default: "disabled" },
-  },
-  Variants.of({
-    disabled: { name: "Disabled", spec: Config.of({}) },
-    system: {
-      name: "System Credentials",
-      spec: Config.of({
-        customFrom: Value.text({
-          name: "Custom From Address",
-          description:
-            "A custom from address for this service. If not provided, the system from address will be used.",
-          required: false,
-          placeholder: "<name>test@example.com",
-          inputmode: "email",
-          patterns: [email],
-        }),
-      }),
-    },
-    custom: {
-      name: "Custom Credentials",
-      spec: customSmtp,
-    },
-  }),
-)

package/lib/config/configDependencies.ts

@@ -1,29 +0,0 @@
-import { SDKManifest } from "../manifest/ManifestTypes"
-import { Dependencies } from "../types"
-
-export type ConfigDependencies<T extends SDKManifest> = {
-  exists(id: keyof T["dependencies"]): Dependencies[number]
-  running(
-    id: keyof T["dependencies"],
-    healthChecks: string[],
-  ): Dependencies[number]
-}
-
-export const configDependenciesSet = <
-  T extends SDKManifest,
->(): ConfigDependencies<T> => ({
-  exists(id: keyof T["dependencies"]) {
-    return {
-      id,
-      kind: "exists",
-    } as Dependencies[number]
-  },
-
-  running(id: keyof T["dependencies"], healthChecks: string[]) {
-    return {
-      id,
-      kind: "running",
-      healthChecks,
-    } as Dependencies[number]
-  },
-})

package/lib/config/configTypes.ts

@@ -1,249 +0,0 @@
-export type InputSpec = Record<string, ValueSpec>
-export type ValueType =
-  | "text"
-  | "textarea"
-  | "number"
-  | "color"
-  | "datetime"
-  | "toggle"
-  | "select"
-  | "multiselect"
-  | "list"
-  | "object"
-  | "file"
-  | "union"
-export type ValueSpec = ValueSpecOf<ValueType>
-/** core spec types. These types provide the metadata for performing validations */
-// prettier-ignore
-export type ValueSpecOf<T extends ValueType> = T extends "text"
-  ? ValueSpecText
-  : T extends "textarea"
-    ? ValueSpecTextarea
-    : T extends "number"
-      ? ValueSpecNumber
-      : T extends "color"
-        ? ValueSpecColor
-        : T extends "datetime"
-          ? ValueSpecDatetime
-          : T extends "toggle"
-            ? ValueSpecToggle
-            : T extends "select"
-              ? ValueSpecSelect
-              : T extends "multiselect"
-                ? ValueSpecMultiselect
-                : T extends "list"
-                  ? ValueSpecList
-                  : T extends "object"
-                    ? ValueSpecObject
-                    : T extends "file"
-                      ? ValueSpecFile
-                      : T extends "union"
-                        ? ValueSpecUnion
-                        : never
-
-export interface ValueSpecText extends ListValueSpecText, WithStandalone {
-  required: boolean
-  default: DefaultString | null
-  disabled: false | string
-  generate: null | RandomString
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecTextarea extends WithStandalone {
-  type: "textarea"
-  placeholder: string | null
-  minLength: number | null
-  maxLength: number | null
-  required: boolean
-  disabled: false | string
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-
-export type FilePath = {
-  filePath: string
-}
-export interface ValueSpecNumber extends ListValueSpecNumber, WithStandalone {
-  required: boolean
-  default: number | null
-  disabled: false | string
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecColor extends WithStandalone {
-  type: "color"
-  required: boolean
-  default: string | null
-  disabled: false | string
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecDatetime extends WithStandalone {
-  type: "datetime"
-  required: boolean
-  inputmode: "date" | "time" | "datetime-local"
-  min: string | null
-  max: string | null
-  default: string | null
-  disabled: false | string
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecSelect extends SelectBase, WithStandalone {
-  type: "select"
-  required: boolean
-  default: string | null
-  /**
-   * Disabled:  false means that there is nothing disabled, good to modify
-   *           string means that this is the message displayed and the whole thing is disabled
-   *           string[] means that the options are disabled
-   */
-  disabled: false | string | string[]
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecMultiselect extends SelectBase, WithStandalone {
-  type: "multiselect"
-  minLength: number | null
-  maxLength: number | null
-  /**
-   * Disabled:  false means that there is nothing disabled, good to modify
-   *           string means that this is the message displayed and the whole thing is disabled
-   *           string[] means that the options are disabled
-   */
-  disabled: false | string | string[]
-  default: string[]
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecToggle extends WithStandalone {
-  type: "toggle"
-  default: boolean | null
-  disabled: false | string
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecUnion extends WithStandalone {
-  type: "union"
-  variants: Record<
-    string,
-    {
-      name: string
-      spec: InputSpec
-    }
-  >
-  /**
-   * Disabled:  false means that there is nothing disabled, good to modify
-   *           string means that this is the message displayed and the whole thing is disabled
-   *           string[] means that the options are disabled
-   */
-  disabled: false | string | string[]
-  required: boolean
-  default: string | null
-  /** Immutable means it can only be configed at the first config then never again */
-  immutable: boolean
-}
-export interface ValueSpecFile extends WithStandalone {
-  type: "file"
-  extensions: string[]
-  required: boolean
-}
-export interface ValueSpecObject extends WithStandalone {
-  type: "object"
-  spec: InputSpec
-}
-export interface WithStandalone {
-  name: string
-  description: string | null
-  warning: string | null
-}
-export interface SelectBase {
-  values: Record<string, string>
-}
-export type ListValueSpecType = "text" | "number" | "object"
-/** represents a spec for the values of a list */
-export type ListValueSpecOf<T extends ListValueSpecType> = T extends "text"
-  ? ListValueSpecText
-  : T extends "number"
-    ? ListValueSpecNumber
-    : T extends "object"
-      ? ListValueSpecObject
-      : never
-/** represents a spec for a list */
-export type ValueSpecList = ValueSpecListOf<ListValueSpecType>
-export interface ValueSpecListOf<T extends ListValueSpecType>
-  extends WithStandalone {
-  type: "list"
-  spec: ListValueSpecOf<T>
-  minLength: number | null
-  maxLength: number | null
-  disabled: false | string
-  default:
-    | string[]
-    | number[]
-    | DefaultString[]
-    | Record<string, unknown>[]
-    | readonly string[]
-    | readonly number[]
-    | readonly DefaultString[]
-    | readonly Record<string, unknown>[]
-}
-export interface Pattern {
-  regex: string
-  description: string
-}
-export interface ListValueSpecText {
-  type: "text"
-  patterns: Pattern[]
-  minLength: number | null
-  maxLength: number | null
-  masked: boolean
-
-  generate: null | RandomString
-  inputmode: "text" | "email" | "tel" | "url"
-  placeholder: string | null
-}
-export interface ListValueSpecNumber {
-  type: "number"
-  min: number | null
-  max: number | null
-  integer: boolean
-  step: number | null
-  units: 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
-  /** 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
-}
-export type UniqueBy =
-  | null
-  | string
-  | {
-      any: readonly UniqueBy[] | UniqueBy[]
-    }
-  | {
-      all: readonly UniqueBy[] | UniqueBy[]
-    }
-export type DefaultString = string | RandomString
-export type RandomString = {
-  charset: string
-  len: number
-}
-// sometimes the type checker needs just a little bit of help
-export function isValueSpecListOf<S extends ListValueSpecType>(
-  t: ValueSpec,
-  s: S,
-): t is ValueSpecListOf<S> & { spec: ListValueSpecOf<S> } {
-  return "spec" in t && t.spec.type === s
-}
-export const unionSelectKey = "unionSelectKey" as const
-export type UnionSelectKey = typeof unionSelectKey
-
-export const unionValueKey = "unionValueKey" as const
-export type UnionValueKey = typeof unionValueKey

package/lib/config/index.ts

@@ -1,3 +0,0 @@
-export * as constants from "./configConstants"
-export * as types from "./configTypes"
-export * as builder from "./builder"

package/lib/config/setupConfig.ts

@@ -1,85 +0,0 @@
-import { Effects, ExpectedExports } from "../types"
-import { SDKManifest } from "../manifest/ManifestTypes"
-import * as D from "./configDependencies"
-import { Config, ExtractConfigType } from "./builder/config"
-import nullIfEmpty from "../util/nullIfEmpty"
-import { InterfacesReceipt as InterfacesReceipt } from "../interfaces/setupInterfaces"
-
-declare const dependencyProof: unique symbol
-export type DependenciesReceipt = void & {
-  [dependencyProof]: never
-}
-
-export type Save<
-  A extends
-    | Record<string, any>
-    | Config<Record<string, any>, any>
-    | Config<Record<string, never>, never>,
-> = (options: {
-  effects: Effects
-  input: ExtractConfigType<A> & Record<string, any>
-}) => Promise<{
-  dependenciesReceipt: DependenciesReceipt
-  interfacesReceipt: InterfacesReceipt
-  restart: boolean
-}>
-export type Read<
-  Manifest extends SDKManifest,
-  Store,
-  A extends
-    | Record<string, any>
-    | Config<Record<string, any>, any>
-    | Config<Record<string, any>, never>,
-> = (options: {
-  effects: Effects
-}) => Promise<void | (ExtractConfigType<A> & Record<string, any>)>
-/**
- * We want to setup a config export with a get and set, this
- * is going to be the default helper to setup config, because it will help
- * enforce that we have a spec, write, and reading.
- * @param options
- * @returns
- */
-export function setupConfig<
-  Store,
-  ConfigType extends
-    | Record<string, any>
-    | Config<any, any>
-    | Config<any, never>,
-  Manifest extends SDKManifest,
-  Type extends Record<string, any> = ExtractConfigType<ConfigType>,
->(
-  spec: Config<Type, Store> | Config<Type, never>,
-  write: Save<Type>,
-  read: Read<Manifest, Store, Type>,
-) {
-  const validator = spec.validator
-  return {
-    setConfig: (async ({ effects, input }) => {
-      if (!validator.test(input)) {
-        await console.error(String(validator.errorMessage(input)))
-        return { error: "Set config type error for config" }
-      }
-      await effects.clearBindings()
-      await effects.clearServiceInterfaces()
-      const { restart } = await write({
-        input: JSON.parse(JSON.stringify(input)) as any,
-        effects,
-      })
-      if (restart) {
-        await effects.restart()
-      }
-    }) as ExpectedExports.setConfig,
-    getConfig: (async ({ effects }) => {
-      const configValue = nullIfEmpty((await read({ effects })) || null)
-      return {
-        spec: await spec.build({
-          effects,
-        }),
-        config: configValue,
-      }
-    }) as ExpectedExports.getConfig,
-  }
-}
-
-export default setupConfig

package/lib/dependencies/DependencyConfig.ts

@@ -1,44 +0,0 @@
-import {
-  DependencyConfig as DependencyConfigType,
-  DeepPartial,
-  Effects,
-} from "../types"
-import { deepEqual } from "../util/deepEqual"
-import { deepMerge } from "../util/deepMerge"
-import { SDKManifest } from "../manifest/ManifestTypes"
-
-export type Update<QueryResults, RemoteConfig> = (options: {
-  remoteConfig: RemoteConfig
-  queryResults: QueryResults
-}) => Promise<RemoteConfig>
-
-export class DependencyConfig<
-  Manifest extends SDKManifest,
-  Store,
-  Input extends Record<string, any>,
-  RemoteConfig extends Record<string, any>,
-> {
-  static defaultUpdate = async (options: {
-    queryResults: unknown
-    remoteConfig: unknown
-  }): Promise<unknown> => {
-    return deepMerge({}, options.remoteConfig, options.queryResults || {})
-  }
-  constructor(
-    readonly dependencyConfig: (options: {
-      effects: Effects
-      localConfig: Input
-    }) => Promise<void | DeepPartial<RemoteConfig>>,
-    readonly update: Update<
-      void | DeepPartial<RemoteConfig>,
-      RemoteConfig
-    > = DependencyConfig.defaultUpdate as any,
-  ) {}
-
-  async query(options: { effects: Effects; localConfig: unknown }) {
-    return this.dependencyConfig({
-      localConfig: options.localConfig as Input,
-      effects: options.effects,
-    })
-  }
-}