Start9/start-os
2
0
Fork 0
mirror of https://github.com/Start9Labs/start-os.git synced 2026-03-30 04:01:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

misc sdk changes (#2934)

Browse Source 
* misc sdk changes

* delete the store ☠️

* port comments

* fix build

* fix removing

* fix tests

* beta.20

---------

Co-authored-by: Matt Hill <mattnine@protonmail.com>
This commit is contained in:
Aiden McClelland
2025-05-09 15:10:51 -06:00
committed by GitHub
parent d2c4741f0b
commit 7750e33f82
62 changed files with 1255 additions and 2130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
sdk/base/lib/Effects.ts
View File

@@ -15,7 +15,6 @@ import {
RequestActionParams,
MainStatus,
} from "./osBindings"
import { StorePath } from "./util/PathBuilder"
import {
PackageId,
Dependencies,
@@ -93,8 +92,6 @@ export type Effects = {
}): Promise<string>
/** Returns a list of the ids of all installed packages */
getInstalledPackages(): Promise<string[]>
/** grants access to certain paths in the store to dependents */
exposeForDependents(options: { paths: string[] }): Promise<null>
// health
/** sets the result of a health check */
@@ -170,23 +167,6 @@ export type Effects = {
algorithm?: "ecdsa" | "ed25519"
}) => Promise<string>
// store
store: {
/** Get a value in a json like data, can be observed and subscribed */
get<Store = never, ExtractStore = unknown>(options: {
/** If there is no packageId it is assumed the current package */
packageId?: string
/** The path defaults to root level, using the [JsonPath](https://jsonpath.com/) */
path: StorePath
callback?: () => void
}): Promise<ExtractStore>
/** Used to store values that can be accessed and subscribed to */
set<Store = never, ExtractStore = unknown>(options: {
/** Sets the value for the wrapper at the path, it will override, using the [JsonPath](https://jsonpath.com/) */
path: StorePath
value: ExtractStore
}): Promise<null>
}
/** sets the version that this service's data has been migrated to */
setDataVersion(options: { version: string }): Promise<null>
/** returns the version that this service's data has been migrated to */

10
sdk/base/lib/actions/index.ts
View File

@@ -45,18 +45,18 @@ export const runAction = async <
})
}
}
type GetActionInputType<A extends Action<T.ActionId, any, any>> =
A extends Action<T.ActionId, any, infer I> ? ExtractInputSpecType<I> : never
type GetActionInputType<A extends Action<T.ActionId, any>> =
A extends Action<T.ActionId, infer I> ? ExtractInputSpecType<I> : never
type ActionRequestBase = {
reason?: string
replayId?: string
}
type ActionRequestInput<T extends Action<T.ActionId, any, any>> = {
type ActionRequestInput<T extends Action<T.ActionId, any>> = {
kind: "partial"
value: T.DeepPartial<GetActionInputType<T>>
}
export type ActionRequestOptions<T extends Action<T.ActionId, any, any>> =
export type ActionRequestOptions<T extends Action<T.ActionId, any>> =
ActionRequestBase &
(
| {
@@ -78,7 +78,7 @@ const _validate: T.ActionRequest = {} as ActionRequestOptions<any> & {
severity: T.ActionSeverity
}
export const requestAction = <T extends Action<T.ActionId, any, any>>(options: {
export const requestAction = <T extends Action<T.ActionId, any>>(options: {
effects: T.Effects
packageId: T.PackageId
action: T

67
sdk/base/lib/actions/input/builder/inputSpec.ts
View File

@@ -5,32 +5,27 @@ import { Effects } from "../../../Effects"
import { Parser, object } from "ts-matches"
import { DeepPartial } from "../../../types"
export type LazyBuildOptions<Store> = {
export type LazyBuildOptions = {
effects: Effects
}
export type LazyBuild<Store, ExpectedOut> = (
options: LazyBuildOptions<Store>,
export type LazyBuild<ExpectedOut> = (
options: LazyBuildOptions,
) => Promise<ExpectedOut> | ExpectedOut
// prettier-ignore
export type ExtractInputSpecType<A extends Record<string, any> | InputSpec<Record<string, any>, any> | InputSpec<Record<string, any>, never>> =
A extends InputSpec<infer B, any> | InputSpec<infer B, never> ? B :
export type ExtractInputSpecType<A extends Record<string, any> | InputSpec<Record<string, any>>> =
A extends InputSpec<infer B> ? B :
A
export type ExtractPartialInputSpecType<
A extends
| Record<string, any>
| InputSpec<Record<string, any>, any>
| InputSpec<Record<string, any>, never>,
> = A extends InputSpec<infer B, any> | InputSpec<infer B, never>
? DeepPartial<B>
: DeepPartial<A>
A extends Record<string, any> | InputSpec<Record<string, any>>,
> = A extends InputSpec<infer B> ? DeepPartial<B> : DeepPartial<A>
export type InputSpecOf<A extends Record<string, any>, Store = never> = {
[K in keyof A]: Value<A[K], Store>
export type InputSpecOf<A extends Record<string, any>> = {
[K in keyof A]: Value<A[K]>
}
export type MaybeLazyValues<A> = LazyBuild<any, A> | A
export type MaybeLazyValues<A> = LazyBuild<A> | A
/**
* InputSpecs are the specs that are used by the os input specification form for this service.
* Here is an example of a simple input specification
@@ -87,16 +82,16 @@ export const addNodesSpec = InputSpec.of({ hostname: hostname, port: port });
```
*/
export class InputSpec<Type extends Record<string, any>, Store = never> {
export class InputSpec<Type extends Record<string, any>> {
private constructor(
private readonly spec: {
[K in keyof Type]: Value<Type[K], Store> | Value<Type[K], never>
[K in keyof Type]: Value<Type[K]>
},
public validator: Parser<unknown, Type>,
) {}
public _TYPE: Type = null as any as Type
public _PARTIAL: DeepPartial<Type> = null as any as DeepPartial<Type>
async build(options: LazyBuildOptions<Store>) {
async build(options: LazyBuildOptions) {
const answer = {} as {
[K in keyof Type]: ValueSpec
}
@@ -106,10 +101,7 @@ export class InputSpec<Type extends Record<string, any>, Store = never> {
return answer
}
static of<
Spec extends Record<string, Value<any, Store> | Value<any, never>>,
Store = never,
>(spec: Spec) {
static of<Spec extends Record<string, Value<any>>>(spec: Spec) {
const validatorObj = {} as {
[K in keyof Spec]: Parser<unknown, any>
}
@@ -117,33 +109,8 @@ export class InputSpec<Type extends Record<string, any>, Store = never> {
validatorObj[key] = spec[key].validator
}
const validator = object(validatorObj)
return new InputSpec<
{
[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/ inputSpec is constructed somewhere else.
```ts
const a = InputSpec.text({
name: "a",
required: false,
})
return InputSpec.of<Store>()({
myValue: a.withStore(),
})
```
*/
withStore<NewStore extends Store extends never ? any : Store>() {
return this as any as InputSpec<Type, NewStore>
return new InputSpec<{
[K in keyof Spec]: Spec[K] extends Value<infer T> ? T : never
}>(spec, validator as any)
}
}

67
sdk/base/lib/actions/input/builder/list.ts
View File

@@ -9,9 +9,9 @@ import {
} from "../inputSpecTypes"
import { Parser, arrayOf, string } from "ts-matches"
export class List<Type, Store> {
export class List<Type> {
private constructor(
public build: LazyBuild<Store, ValueSpecList>,
public build: LazyBuild<ValueSpecList>,
public validator: Parser<unknown, Type>,
) {}
@@ -58,7 +58,7 @@ export class List<Type, Store> {
generate?: null | RandomString
},
) {
return new List<string[], never>(() => {
return new List<string[]>(() => {
const spec = {
type: "text" as const,
placeholder: null,
@@ -85,30 +85,27 @@ export class List<Type, Store> {
}, arrayOf(string))
}
static dynamicText<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default?: string[]
static dynamicText(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default?: string[]
minLength?: number | null
maxLength?: number | null
disabled?: false | string
generate?: null | RandomString
spec: {
masked?: boolean
placeholder?: string | null
minLength?: number | null
maxLength?: number | null
disabled?: false | string
generate?: null | RandomString
spec: {
masked?: boolean
placeholder?: string | null
minLength?: number | null
maxLength?: number | null
patterns?: Pattern[]
inputmode?: ListValueSpecText["inputmode"]
}
patterns?: Pattern[]
inputmode?: ListValueSpecText["inputmode"]
}
>,
}>,
) {
return new List<string[], Store>(async (options) => {
return new List<string[]>(async (options) => {
const { spec: aSpec, ...a } = await getA(options)
const spec = {
type: "text" as const,
@@ -136,7 +133,7 @@ export class List<Type, Store> {
}, arrayOf(string))
}
static obj<Type extends Record<string, any>, Store>(
static obj<Type extends Record<string, any>>(
a: {
name: string
description?: string | null
@@ -146,12 +143,12 @@ export class List<Type, Store> {
maxLength?: number | null
},
aSpec: {
spec: InputSpec<Type, Store>
spec: InputSpec<Type>
displayAs?: null | string
uniqueBy?: null | UniqueBy
},
) {
return new List<Type[], Store>(async (options) => {
return new List<Type[]>(async (options) => {
const { spec: previousSpecSpec, ...restSpec } = aSpec
const specSpec = await previousSpecSpec.build(options)
const spec = {
@@ -177,22 +174,4 @@ export class List<Type, Store> {
}
}, arrayOf(aSpec.spec.validator))
}
/**
* Use this during the times that the input needs a more specific type.
* Used in types that the value/ variant/ list/ inputSpec is constructed somewhere else.
```ts
const a = InputSpec.text({
name: "a",
required: false,
})
return InputSpec.of<Store>()({
myValue: a.withStore(),
})
```
*/
withStore<NewStore extends Store extends never ? any : Store>() {
return this as any as List<Type, NewStore>
}
}

619
sdk/base/lib/actions/input/builder/value.ts
View File

@@ -24,7 +24,6 @@ import {
number,
object,
string,
unknown,
} from "ts-matches"
import { DeepPartial } from "../../../types"
@@ -44,14 +43,30 @@ function asRequiredParser<
return parser.nullable() as any
}
export class Value<Type, Store> {
export class Value<Type> {
protected constructor(
public build: LazyBuild<Store, ValueSpec>,
public build: LazyBuild<ValueSpec>,
public validator: Parser<unknown, Type>,
) {}
public _TYPE: Type = null as any as Type
public _PARTIAL: DeepPartial<Type> = null as any as DeepPartial<Type>
/**
* @description Displays a boolean toggle to enable/disable
* @example
* ```
toggleExample: Value.toggle({
// required
name: 'Toggle Example',
default: true,
// optional
description: null,
warning: null,
immutable: false,
}),
* ```
*/
static toggle(a: {
name: string
description?: string | null
@@ -64,7 +79,7 @@ export class Value<Type, Store> {
*/
immutable?: boolean
}) {
return new Value<boolean, never>(
return new Value<boolean>(
async () => ({
description: null,
warning: null,
@@ -76,19 +91,16 @@ export class Value<Type, Store> {
boolean,
)
}
static dynamicToggle<Store = never>(
a: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: boolean
disabled?: false | string
}
>,
static dynamicToggle(
a: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: boolean
disabled?: false | string
}>,
) {
return new Value<boolean, Store>(
return new Value<boolean>(
async (options) => ({
description: null,
warning: null,
@@ -100,6 +112,30 @@ export class Value<Type, Store> {
boolean,
)
}
/**
* @description Displays a text input field
* @example
* ```
textExample: Value.text({
// required
name: 'Text Example',
required: false,
default: null,
// optional
description: null,
placeholder: null,
warning: null,
generate: null,
inputmode: 'text',
masked: false,
minLength: null,
maxLength: null,
patterns: [],
immutable: false,
}),
* ```
*/
static text<Required extends boolean>(a: {
name: string
description?: string | null
@@ -151,7 +187,7 @@ export class Value<Type, Store> {
*/
generate?: RandomString | null
}) {
return new Value<AsRequired<string, Required>, never>(
return new Value<AsRequired<string, Required>>(
async () => ({
type: "text" as const,
description: null,
@@ -170,27 +206,24 @@ export class Value<Type, Store> {
asRequiredParser(string, a),
)
}
static dynamicText<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: DefaultString | null
required: boolean
masked?: boolean
placeholder?: string | null
minLength?: number | null
maxLength?: number | null
patterns?: Pattern[]
inputmode?: ValueSpecText["inputmode"]
disabled?: string | false
generate?: null | RandomString
}
>,
static dynamicText(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: DefaultString | null
required: boolean
masked?: boolean
placeholder?: string | null
minLength?: number | null
maxLength?: number | null
patterns?: Pattern[]
inputmode?: ValueSpecText["inputmode"]
disabled?: string | false
generate?: null | RandomString
}>,
) {
return new Value<string | null, Store>(async (options) => {
return new Value<string | null>(async (options) => {
const a = await getA(options)
return {
type: "text" as const,
@@ -209,6 +242,26 @@ export class Value<Type, Store> {
}
}, string.nullable())
}
/**
* @description Displays a large textarea field for long form entry.
* @example
* ```
textareaExample: Value.textarea({
// required
name: 'Textarea Example',
required: false,
default: null,
// optional
description: null,
placeholder: null,
warning: null,
minLength: null,
maxLength: null,
immutable: false,
}),
* ```
*/
static textarea<Required extends boolean>(a: {
name: string
description?: string | null
@@ -225,7 +278,7 @@ export class Value<Type, Store> {
*/
immutable?: boolean
}) {
return new Value<AsRequired<string, Required>, never>(
return new Value<AsRequired<string, Required>>(
async () => {
const built: ValueSpecTextarea = {
description: null,
@@ -243,23 +296,20 @@ export class Value<Type, Store> {
asRequiredParser(string, a),
)
}
static dynamicTextarea<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: string | null
required: boolean
minLength?: number | null
maxLength?: number | null
placeholder?: string | null
disabled?: false | string
}
>,
static dynamicTextarea(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: string | null
required: boolean
minLength?: number | null
maxLength?: number | null
placeholder?: string | null
disabled?: false | string
}>,
) {
return new Value<string | null, Store>(async (options) => {
return new Value<string | null>(async (options) => {
const a = await getA(options)
return {
description: null,
@@ -274,6 +324,29 @@ export class Value<Type, Store> {
}
}, string.nullable())
}
/**
* @description Displays a number input field
* @example
* ```
numberExample: Value.number({
// required
name: 'Number Example',
required: false,
default: null,
integer: true,
// optional
description: null,
placeholder: null,
warning: null,
min: null,
max: null,
immutable: false,
step: null,
units: null,
}),
* ```
*/
static number<Required extends boolean>(a: {
name: string
description?: string | null
@@ -309,7 +382,7 @@ export class Value<Type, Store> {
*/
immutable?: boolean
}) {
return new Value<AsRequired<number, Required>, never>(
return new Value<AsRequired<number, Required>>(
() => ({
type: "number" as const,
description: null,
@@ -326,26 +399,23 @@ export class Value<Type, Store> {
asRequiredParser(number, a),
)
}
static dynamicNumber<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: number | null
required: boolean
min?: number | null
max?: number | null
step?: number | null
integer: boolean
units?: string | null
placeholder?: string | null
disabled?: false | string
}
>,
static dynamicNumber(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: number | null
required: boolean
min?: number | null
max?: number | null
step?: number | null
integer: boolean
units?: string | null
placeholder?: string | null
disabled?: false | string
}>,
) {
return new Value<number | null, Store>(async (options) => {
return new Value<number | null>(async (options) => {
const a = await getA(options)
return {
type: "number" as const,
@@ -362,6 +432,23 @@ export class Value<Type, Store> {
}
}, number.nullable())
}
/**
* @description Displays a browser-native color selector.
* @example
* ```
colorExample: Value.color({
// required
name: 'Color Example',
required: false,
default: null,
// optional
description: null,
warning: null,
immutable: false,
}),
* ```
*/
static color<Required extends boolean>(a: {
name: string
description?: string | null
@@ -381,7 +468,7 @@ export class Value<Type, Store> {
*/
immutable?: boolean
}) {
return new Value<AsRequired<string, Required>, never>(
return new Value<AsRequired<string, Required>>(
() => ({
type: "color" as const,
description: null,
@@ -394,20 +481,17 @@ export class Value<Type, Store> {
)
}
static dynamicColor<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: string | null
required: boolean
disabled?: false | string
}
>,
static dynamicColor(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: string | null
required: boolean
disabled?: false | string
}>,
) {
return new Value<string | null, Store>(async (options) => {
return new Value<string | null>(async (options) => {
const a = await getA(options)
return {
type: "color" as const,
@@ -419,6 +503,26 @@ export class Value<Type, Store> {
}
}, string.nullable())
}
/**
* @description Displays a browser-native date/time selector.
* @example
* ```
datetimeExample: Value.datetime({
// required
name: 'Datetime Example',
required: false,
default: null,
// optional
description: null,
warning: null,
immutable: false,
inputmode: 'datetime-local',
min: null,
max: null,
}),
* ```
*/
static datetime<Required extends boolean>(a: {
name: string
description?: string | null
@@ -445,7 +549,7 @@ export class Value<Type, Store> {
*/
immutable?: boolean
}) {
return new Value<AsRequired<string, Required>, never>(
return new Value<AsRequired<string, Required>>(
() => ({
type: "datetime" as const,
description: null,
@@ -461,23 +565,20 @@ export class Value<Type, Store> {
asRequiredParser(string, a),
)
}
static dynamicDatetime<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: string | null
required: boolean
inputmode?: ValueSpecDatetime["inputmode"]
min?: string | null
max?: string | null
disabled?: false | string
}
>,
static dynamicDatetime(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: string | null
required: boolean
inputmode?: ValueSpecDatetime["inputmode"]
min?: string | null
max?: string | null
disabled?: false | string
}>,
) {
return new Value<string | null, Store>(async (options) => {
return new Value<string | null>(async (options) => {
const a = await getA(options)
return {
type: "datetime" as const,
@@ -492,6 +593,27 @@ export class Value<Type, Store> {
}
}, string.nullable())
}
/**
* @description Displays a select modal with radio buttons, allowing for a single selection.
* @example
* ```
selectExample: Value.select({
// required
name: 'Select Example',
default: 'radio1',
values: {
radio1: 'Radio 1',
radio2: 'Radio 2',
},
// optional
description: null,
warning: null,
immutable: false,
disabled: false,
}),
* ```
*/
static select<Values extends Record<string, string>>(a: {
name: string
description?: string | null
@@ -522,7 +644,7 @@ export class Value<Type, Store> {
*/
immutable?: boolean
}) {
return new Value<keyof Values & string, never>(
return new Value<keyof Values & string>(
() => ({
description: null,
warning: null,
@@ -536,20 +658,17 @@ export class Value<Type, Store> {
),
)
}
static dynamicSelect<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: string
values: Record<string, string>
disabled?: false | string | string[]
}
>,
static dynamicSelect(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: string
values: Record<string, string>
disabled?: false | string | string[]
}>,
) {
return new Value<string, Store>(async (options) => {
return new Value<string>(async (options) => {
const a = await getA(options)
return {
description: null,
@@ -561,6 +680,29 @@ export class Value<Type, Store> {
}
}, string)
}
/**
* @description Displays a select modal with checkboxes, allowing for multiple selections.
* @example
* ```
multiselectExample: Value.multiselect({
// required
name: 'Multiselect Example',
values: {
option1: 'Option 1',
option2: 'Option 2',
},
default: [],
// optional
description: null,
warning: null,
immutable: false,
disabled: false,
minlength: null,
maxLength: null,
}),
* ```
*/
static multiselect<Values extends Record<string, string>>(a: {
name: string
description?: string | null
@@ -590,7 +732,7 @@ export class Value<Type, Store> {
*/
immutable?: boolean
}) {
return new Value<(keyof Values)[], never>(
return new Value<(keyof Values)[]>(
() => ({
type: "multiselect" as const,
minLength: null,
@@ -606,22 +748,19 @@ export class Value<Type, Store> {
),
)
}
static dynamicMultiselect<Store = never>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: string[]
values: Record<string, string>
minLength?: number | null
maxLength?: number | null
disabled?: false | string | string[]
}
>,
static dynamicMultiselect(
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: string[]
values: Record<string, string>
minLength?: number | null
maxLength?: number | null
disabled?: false | string | string[]
}>,
) {
return new Value<string[], Store>(async (options) => {
return new Value<string[]>(async (options) => {
const a = await getA(options)
return {
type: "multiselect" as const,
@@ -635,14 +774,31 @@ export class Value<Type, Store> {
}
}, arrayOf(string))
}
static object<Type extends Record<string, any>, Store>(
/**
* @description Display a collapsable grouping of additional fields, a "sub form". The second value is the inputSpec spec for the sub form.
* @example
* ```
objectExample: Value.object(
{
// required
name: 'Object Example',
// optional
description: null,
warning: null,
},
InputSpec.of({}),
),
* ```
*/
static object<Type extends Record<string, any>>(
a: {
name: string
description?: string | null
},
spec: InputSpec<Type, Store>,
spec: InputSpec<Type>,
) {
return new Value<Type, Store>(async (options) => {
return new Value<Type>(async (options) => {
const built = await spec.build(options as any)
return {
type: "object" as const,
@@ -694,14 +850,42 @@ export class Value<Type, Store> {
// object({ filePath: string }).nullable(),
// )
// }
/**
* @description Displays a dropdown, allowing for a single selection. Depending on the selection, a different object ("sub form") is presented.
* @example
* ```
unionExample: Value.union(
{
// required
name: 'Union Example',
default: 'option1',
// optional
description: null,
warning: null,
disabled: false,
immutable: false,
},
Variants.of({
option1: {
name: 'Option 1',
spec: InputSpec.of({}),
},
option2: {
name: 'Option 2',
spec: InputSpec.of({}),
},
}),
),
* ```
*/
static union<
VariantValues extends {
[K in string]: {
name: string
spec: InputSpec<any, Store> | InputSpec<any, never>
spec: InputSpec<any>
}
},
Store,
>(
a: {
name: string
@@ -720,9 +904,9 @@ export class Value<Type, Store> {
*/
immutable?: boolean
},
aVariants: Variants<VariantValues, Store>,
aVariants: Variants<VariantValues>,
) {
return new Value<typeof aVariants.validator._TYPE, Store>(
return new Value<typeof aVariants.validator._TYPE>(
async (options) => ({
type: "union" as const,
description: null,
@@ -739,21 +923,20 @@ export class Value<Type, Store> {
VariantValues extends {
[K in string]: {
name: string
spec: InputSpec<any, Store> | InputSpec<any, never>
spec: InputSpec<any>
}
},
Store,
>(
getDisabledFn: LazyBuild<Store, string[] | false | string>,
getDisabledFn: LazyBuild<string[] | false | string>,
a: {
name: string
description?: string | null
warning?: string | null
default: keyof VariantValues & string
},
aVariants: Variants<VariantValues, Store> | Variants<VariantValues, never>,
aVariants: Variants<VariantValues>,
) {
return new Value<typeof aVariants.validator._TYPE, Store>(
return new Value<typeof aVariants.validator._TYPE>(
async (options) => ({
type: "union" as const,
description: null,
@@ -770,45 +953,107 @@ export class Value<Type, Store> {
VariantValues extends {
[K in string]: {
name: string
spec: InputSpec<any, Store> | InputSpec<any, never>
spec: InputSpec<any>
}
},
Store,
>(
getA: LazyBuild<
Store,
{
name: string
description?: string | null
warning?: string | null
default: keyof VariantValues & string
disabled: string[] | false | string
}
>,
aVariants: Variants<VariantValues, Store> | Variants<VariantValues, never>,
getA: LazyBuild<{
name: string
description?: string | null
warning?: string | null
default: keyof VariantValues & string
disabled: string[] | false | string
}>,
aVariants: Variants<VariantValues>,
) {
return new Value<typeof aVariants.validator._TYPE, Store>(
async (options) => {
const newValues = await getA(options)
return {
type: "union" as const,
return new Value<typeof aVariants.validator._TYPE>(async (options) => {
const newValues = await getA(options)
return {
type: "union" as const,
description: null,
warning: null,
...newValues,
variants: await aVariants.build(options as any),
immutable: false,
}
}, aVariants.validator)
}
/**
* @description Presents an interface to add/remove/edit items in a list.
* @example
* In this example, we create a list of text inputs.
*
* ```
listExampleText: Value.list(
List.text(
{
// required
name: 'Text List',
// optional
description: null,
warning: null,
...newValues,
variants: await aVariants.build(options as any),
immutable: false,
}
},
aVariants.validator,
)
}
static list<Type, Store>(a: List<Type, Store>) {
return new Value<Type, Store>((options) => a.build(options), a.validator)
default: [],
minLength: null,
maxLength: null,
},
{
// required
patterns: [],
// optional
placeholder: null,
generate: null,
inputmode: 'url',
masked: false,
minLength: null,
maxLength: null,
},
),
),
* ```
* @example
* In this example, we create a list of objects.
*
* ```
listExampleObject: Value.list(
List.obj(
{
// required
name: 'Object List',
// optional
description: null,
warning: null,
default: [],
minLength: null,
maxLength: null,
},
{
// required
spec: InputSpec.of({}),
// optional
displayAs: null,
uniqueBy: null,
},
),
),
* ```
*/
static list<Type>(a: List<Type>) {
return new Value<Type>((options) => a.build(options), a.validator)
}
/**
* @description Provides a way to define a hidden field with a static value. Useful for tracking
* @example
* ```
hiddenExample: Value.hidden(),
* ```
*/
static hidden<T>(parser: Parser<unknown, T> = any) {
return new Value<T, never>(async () => {
return new Value<T>(async () => {
const built: ValueSpecHidden = {
type: "hidden" as const,
}
@@ -816,25 +1061,7 @@ export class Value<Type, Store> {
}, parser)
}
map<U>(fn: (value: Type) => U): Value<U, Store> {
map<U>(fn: (value: Type) => U): Value<U> {
return new Value(this.build, this.validator.map(fn))
}
/**
* Use this during the times that the input needs a more specific type.
* Used in types that the value/ variant/ list/ inputSpec is constructed somewhere else.
```ts
const a = InputSpec.text({
name: "a",
required: false,
})
return InputSpec.of<Store>()({
myValue: a.withStore(),
})
```
*/
withStore<NewStore extends Store extends never ? any : Store>() {
return this as any as Value<Type, NewStore>
}
}

32
sdk/base/lib/actions/input/builder/variants.ts
View File

@@ -9,11 +9,10 @@ import {
import { Parser, anyOf, literal, object } from "ts-matches"
export type UnionRes<
Store,
VariantValues extends {
[K in string]: {
name: string
spec: InputSpec<any, Store> | InputSpec<any, never>
spec: InputSpec<any>
}
},
K extends keyof VariantValues & string = keyof VariantValues & string,
@@ -81,23 +80,21 @@ export class Variants<
VariantValues extends {
[K in string]: {
name: string
spec: InputSpec<any, Store> | InputSpec<any, never>
spec: InputSpec<any>
}
},
Store,
> {
private constructor(
public build: LazyBuild<Store, ValueSpecUnion["variants"]>,
public validator: Parser<unknown, UnionRes<Store, VariantValues>>,
public build: LazyBuild<ValueSpecUnion["variants"]>,
public validator: Parser<unknown, UnionRes<VariantValues>>,
) {}
static of<
VariantValues extends {
[K in string]: {
name: string
spec: InputSpec<any, Store> | InputSpec<any, never>
spec: InputSpec<any>
}
},
Store = never,
>(a: VariantValues) {
const validator = anyOf(
...Object.entries(a).map(([id, { spec }]) =>
@@ -108,7 +105,7 @@ export class Variants<
),
) as Parser<unknown, any>
return new Variants<VariantValues, Store>(async (options) => {
return new Variants<VariantValues>(async (options) => {
const variants = {} as {
[K in keyof VariantValues]: {
name: string
@@ -125,21 +122,4 @@ export class Variants<
return variants
}, validator)
}
/**
* Use this during the times that the input needs a more specific type.
* Used in types that the value/ variant/ list/ inputSpec is constructed somewhere else.
```ts
const a = InputSpec.text({
name: "a",
required: false,
})
return InputSpec.of<Store>()({
myValue: a.withStore(),
})
```
*/
withStore<NewStore extends Store extends never ? any : Store>() {
return this as any as Variants<VariantValues, NewStore>
}
}

2
sdk/base/lib/actions/input/inputSpecConstants.ts
View File

@@ -7,7 +7,7 @@ import { Variants } from "./builder/variants"
/**
* Base SMTP settings, to be used by StartOS for system wide SMTP
*/
export const customSmtp = InputSpec.of<InputSpecOf<SmtpValue>, never>({
export const customSmtp = InputSpec.of<InputSpecOf<SmtpValue>>({
server: Value.text({
name: "SMTP Server",
required: true,

39
sdk/base/lib/actions/setupActions.ts
View File

@@ -7,19 +7,13 @@ import * as T from "../types"
import { once } from "../util"
export type Run<
A extends
| Record<string, any>
| InputSpec<Record<string, any>, any>
| InputSpec<Record<string, never>, never>,
A extends Record<string, any> | InputSpec<Record<string, any>>,
> = (options: {
effects: T.Effects
input: ExtractInputSpecType<A>
}) => Promise<(T.ActionResult & { version: "1" }) | null | void | undefined>
export type GetInput<
A extends
| Record<string, any>
| InputSpec<Record<string, any>, any>
| InputSpec<Record<string, any>, never>,
A extends Record<string, any> | InputSpec<Record<string, any>>,
> = (options: {
effects: T.Effects
}) => Promise<null | void | undefined | ExtractPartialInputSpecType<A>>
@@ -48,11 +42,7 @@ function mapMaybeFn<T, U>(
export class Action<
Id extends T.ActionId,
Store,
InputSpecType extends
| Record<string, any>
| InputSpec<any, Store>
| InputSpec<any, never>,
InputSpecType extends Record<string, any> | InputSpec<any>,
> {
private constructor(
readonly id: Id,
@@ -63,18 +53,14 @@ export class Action<
) {}
static withInput<
Id extends T.ActionId,
Store,
InputSpecType extends
| Record<string, any>
| InputSpec<any, Store>
| InputSpec<any, never>,
InputSpecType extends Record<string, any> | InputSpec<any>,
>(
id: Id,
metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>,
inputSpec: InputSpecType,
getInput: GetInput<InputSpecType>,
run: Run<InputSpecType>,
): Action<Id, Store, InputSpecType> {
): Action<Id, InputSpecType> {
return new Action(
id,
mapMaybeFn(metadata, (m) => ({ ...m, hasInput: true })),
@@ -83,11 +69,11 @@ export class Action<
run,
)
}
static withoutInput<Id extends T.ActionId, Store>(
static withoutInput<Id extends T.ActionId>(
id: Id,
metadata: MaybeFn<Omit<T.ActionMetadata, "hasInput">>,
run: Run<{}>,
): Action<Id, Store, {}> {
): Action<Id, {}> {
return new Action(
id,
mapMaybeFn(metadata, (m) => ({ ...m, hasInput: false })),
@@ -124,16 +110,15 @@ export class Action<
}
export class Actions<
Store,
AllActions extends Record<T.ActionId, Action<T.ActionId, Store, any>>,
AllActions extends Record<T.ActionId, Action<T.ActionId, any>>,
> {
private constructor(private readonly actions: AllActions) {}
static of<Store>(): Actions<Store, {}> {
static of(): Actions<{}> {
return new Actions({})
}
addAction<A extends Action<T.ActionId, Store, any>>(
action: A,
): Actions<Store, AllActions & { [id in A["id"]]: A }> {
addAction<A extends Action<T.ActionId, any>>(
action: A, // TODO: prevent duplicates
): Actions<AllActions & { [id in A["id"]]: A }> {
return new Actions({ ...this.actions, [action.id]: action })
}
async update(options: { effects: T.Effects }): Promise<null> {

2
sdk/base/lib/backup/Backups.ts
View File

@@ -90,7 +90,7 @@ export class Backups<M extends T.Manifest> {
return this
}
addVolume(
mountVolume(
volume: M["volumes"][number],
options?: Partial<{
options: T.SyncOptions

3
sdk/base/lib/osBindings/ExposeForDependentsParams.ts
View File

@@ -1,3 +0,0 @@
// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
export type ExposeForDependentsParams = { paths: string[] }

9
sdk/base/lib/osBindings/GetStoreParams.ts
View File

@@ -1,9 +0,0 @@
// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
import type { CallbackId } from "./CallbackId"
import type { PackageId } from "./PackageId"
export type GetStoreParams = {
packageId?: PackageId
path: string
callback?: CallbackId
}

3
sdk/base/lib/osBindings/SetStoreParams.ts
View File

@@ -1,3 +0,0 @@
// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
export type SetStoreParams = { value: any; path: string }

3
sdk/base/lib/osBindings/index.ts
View File

@@ -77,7 +77,6 @@ export { EditSignerParams } from "./EditSignerParams"
export { EncryptedWire } from "./EncryptedWire"
export { ExportActionParams } from "./ExportActionParams"
export { ExportServiceInterfaceParams } from "./ExportServiceInterfaceParams"
export { ExposeForDependentsParams } from "./ExposeForDependentsParams"
export { FileType } from "./FileType"
export { ForgetInterfaceParams } from "./ForgetInterfaceParams"
export { FullIndex } from "./FullIndex"
@@ -95,7 +94,6 @@ export { GetServicePortForwardParams } from "./GetServicePortForwardParams"
export { GetSslCertificateParams } from "./GetSslCertificateParams"
export { GetSslKeyParams } from "./GetSslKeyParams"
export { GetStatusParams } from "./GetStatusParams"
export { GetStoreParams } from "./GetStoreParams"
export { GetSystemSmtpParams } from "./GetSystemSmtpParams"
export { GigaBytes } from "./GigaBytes"
export { GitHash } from "./GitHash"
@@ -195,7 +193,6 @@ export { SetIconParams } from "./SetIconParams"
export { SetMainStatusStatus } from "./SetMainStatusStatus"
export { SetMainStatus } from "./SetMainStatus"
export { SetNameParams } from "./SetNameParams"
export { SetStoreParams } from "./SetStoreParams"
export { SetupExecuteParams } from "./SetupExecuteParams"
export { SetupProgress } from "./SetupProgress"
export { SetupResult } from "./SetupResult"

6
sdk/base/lib/test/startosTypeValidation.test.ts
View File

@@ -19,7 +19,6 @@ import { DestroySubcontainerFsParams } from ".././osBindings"
import { BindParams } from ".././osBindings"
import { GetHostInfoParams } from ".././osBindings"
import { SetHealth } from ".././osBindings"
import { ExposeForDependentsParams } from ".././osBindings"
import { GetSslCertificateParams } from ".././osBindings"
import { GetSslKeyParams } from ".././osBindings"
import { GetServiceInterfaceParams } from ".././osBindings"
@@ -71,15 +70,10 @@ describe("startosTypeValidation ", () => {
setDataVersion: {} as SetDataVersionParams,
getDataVersion: undefined,
setHealth: {} as SetHealth,
exposeForDependents: {} as ExposeForDependentsParams,
getSslCertificate: {} as WithCallback<GetSslCertificateParams>,
getSslKey: {} as GetSslKeyParams,
getServiceInterface: {} as WithCallback<GetServiceInterfaceParams>,
setDependencies: {} as SetDependenciesParams,
store: {
get: {} as any, // as GetStoreParams,
set: {} as any, // as SetStoreParams,
},
getSystemSmtp: {} as WithCallback<GetSystemSmtpParams>,
getContainerIp: {} as WithCallback<GetContainerIpParams>,
getOsIp: undefined,

11
sdk/base/lib/types.ts
View File

@@ -19,8 +19,6 @@ export {
CurrentDependenciesResult,
} from "./dependencies/setupDependencies"
export type ExposedStorePaths = string[] & Affine<"ExposedStorePaths">
export type DaemonBuildable = {
build(): Promise<{
term(): Promise<void>
@@ -85,10 +83,7 @@ export namespace ExpectedExports {
export type manifest = Manifest
export type actions = Actions<
any,
Record<ActionId, Action<ActionId, any, any>>
>
export type actions = Actions<Record<ActionId, Action<ActionId, any>>>
}
export type ABI = {
createBackup: ExpectedExports.createBackup
@@ -141,10 +136,6 @@ export type Hostname = string & { [hostName]: never }
export type ServiceInterfaceId = string
export { ServiceInterface }
export type ExposeServicePaths<Store = never> = {
/** The path to the value in the Store. [JsonPath](https://jsonpath.com/) */
paths: ExposedStorePaths
}
export type EffectMethod<T extends StringObject = Effects> = {
[K in keyof T]-?: K extends string

38
sdk/base/lib/util/PathBuilder.ts
View File

@@ -1,38 +0,0 @@
import { Affine } from "../util"
const pathValue = Symbol("pathValue")
export type PathValue = typeof pathValue
export type PathBuilderStored<AllStore, Store> = {
[K in PathValue]: [AllStore, Store]
}
export type PathBuilder<AllStore, Store = AllStore> = (Store extends Record<
string,
unknown
>
? {
[K in keyof Store]: PathBuilder<AllStore, Store[K]>
}
: {}) &
PathBuilderStored<AllStore, Store>
export type StorePath = string & Affine<"StorePath">
const privateSymbol = Symbol("jsonPath")
export const extractJsonPath = (builder: PathBuilder<unknown>) => {
return (builder as any)[privateSymbol] as StorePath
}
export const pathBuilder = <Store, StorePath = Store>(
paths: string[] = [],
): PathBuilder<Store, StorePath> => {
return new Proxy({} as PathBuilder<Store, StorePath>, {
get(target, prop) {
if (prop === privateSymbol) {
if (paths.length === 0) return ""
return `/${paths.join("/")}`
}
return pathBuilder<any>([...paths, prop as string])
},
}) as PathBuilder<Store, StorePath>
}

1
sdk/base/lib/util/index.ts
View File

@@ -17,6 +17,5 @@ export { nullIfEmpty } from "./nullIfEmpty"
export { deepMerge, partialDiff } from "./deepMerge"
export { deepEqual } from "./deepEqual"
export { hostnameInfoToAddress } from "./Hostname"
export { PathBuilder, extractJsonPath, StorePath } from "./PathBuilder"
export * as regexes from "./regexes"
export { stringFromStdErrOut } from "./stringFromStdErrOut"