@highstate/backend 0.9.14 → 0.9.16

package/src/secret/local.ts

@@ -1,152 +0,0 @@
-import type { SecretBackend } from "./abstractions"
-import type { Logger } from "pino"
-import { mapKeys, mapValues, pickBy } from "remeda"
-import { z } from "zod"
-import { LocalPulumiHost, resolveMainLocalProject, stringToValue, valueToString } from "../common"
-
-export const localSecretBackendConfig = z.object({
-  HIGHSTATE_BACKEND_SECRET_PROJECT_PATH: z.string().optional(),
-  HIGHSTATE_BACKEND_SECRET_PROJECT_NAME: z.string().optional(),
-})
-
-/**
- * The backend for storing secrets in the local Pulumi project.
- * It is the simplest backend and should be used for development and single-user projects.
- */
-export class LocalSecretBackend implements SecretBackend {
-  private constructor(
-    private readonly projectPath: string,
-    private readonly projectName: string,
-    private readonly pulumiProjectHost: LocalPulumiHost,
-    private readonly logger: Logger,
-  ) {
-    this.logger.debug({ msg: "initialized", projectPath, projectName })
-  }
-
-  isLocked(projectId: string): Promise<boolean> {
-    return Promise.resolve(!this.pulumiProjectHost.hasPassword(projectId))
-  }
-
-  async unlock(projectId: string, password: string, signal?: AbortSignal): Promise<boolean> {
-    this.pulumiProjectHost.setPassword(projectId, password)
-
-    try {
-      // try to run a command to check if the password is correct
-      await this.pulumiProjectHost.runLocal(
-        {
-          projectId,
-          pulumiProjectName: this.projectName,
-          pulumiStackName: projectId,
-          projectPath: this.projectPath,
-        },
-        async stack => {
-          this.logger.debug({ projectId }, "checking password")
-
-          await stack.info(true)
-        },
-        signal,
-      )
-
-      return true
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error.message.includes("incorrect passphrase")) {
-          this.logger.debug({ projectId, error }, "incorrect passphrase")
-
-          this.pulumiProjectHost.removePassword(projectId)
-          return false
-        }
-      }
-
-      throw error
-    }
-  }
-
-  get(
-    projectId: string,
-    instanceId: string,
-    signal?: AbortSignal,
-  ): Promise<Record<string, unknown>> {
-    return this.pulumiProjectHost.runLocal(
-      {
-        projectId,
-        pulumiProjectName: this.projectName,
-        pulumiStackName: projectId,
-        projectPath: this.projectPath,
-      },
-      async stack => {
-        this.logger.debug({ projectId, instanceId }, "getting secrets")
-
-        const config = await stack.getAllConfig()
-        signal?.throwIfAborted()
-
-        const prefix = this.getPrefix(projectId, instanceId)
-        const secrets = pickBy(config, (_, key) => key.startsWith(prefix))
-        const trimmedSecrets = mapKeys(secrets, key => key.slice(prefix.length))
-
-        return mapValues(trimmedSecrets, value => stringToValue(value.value))
-      },
-      signal,
-    )
-  }
-
-  set(
-    projectId: string,
-    instanceId: string,
-    values: Record<string, unknown>,
-    signal?: AbortSignal,
-  ): Promise<void> {
-    return this.pulumiProjectHost.runLocal(
-      {
-        projectId,
-        pulumiProjectName: this.projectName,
-        pulumiStackName: projectId,
-        projectPath: this.projectPath,
-      },
-      async stack => {
-        this.logger.debug({ projectId, instanceId }, "setting secrets")
-
-        const componentSecrets = mapValues(
-          mapKeys(values, key => `${this.getPrefix(projectId, instanceId)}${key}`),
-          value => ({
-            value: valueToString(value),
-            secret: true,
-          }),
-        )
-
-        const config = await stack.getAllConfig()
-        signal?.throwIfAborted()
-
-        Object.assign(config, componentSecrets)
-
-        await stack.setAllConfig(config)
-      },
-      signal,
-    )
-  }
-
-  private getPrefix(projectId: string, instanceId: string) {
-    // replace all semicolons with dashes since extra semicolons are not allowed in Pulumi config keys
-    instanceId = instanceId.replace(/:/g, "_")
-
-    return `${this.projectName}:${projectId}/${instanceId}/`
-  }
-
-  static async create(
-    config: z.infer<typeof localSecretBackendConfig>,
-    pulumiProjectHost: LocalPulumiHost,
-    logger: Logger,
-  ) {
-    const [projectPath, projectName] = await resolveMainLocalProject(
-      config.HIGHSTATE_BACKEND_SECRET_PROJECT_PATH,
-      config.HIGHSTATE_BACKEND_SECRET_PROJECT_NAME,
-    )
-
-    return new LocalSecretBackend(
-      projectPath,
-      projectName,
-      pulumiProjectHost,
-      logger.child({ backend: "SecretBackend", service: "LocalSecretBackend" }),
-    )
-  }
-}

package/src/shared/state.ts

@@ -1,270 +0,0 @@
-import { omit } from "remeda"
-import { z } from "zod"
-
-export const instanceStatusSchema = z.enum([
-  "not_created",
-  "updating",
-  "previewing",
-  "destroying",
-  "refreshing",
-  "created",
-  "error",
-  "pending",
-  "unknown",
-])
-
-export const instanceStatusFieldValueSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.array(z.string()),
-])
-
-export const instanceStatusFieldSchema = z.object({
-  name: z.string(),
-  value: instanceStatusFieldValueSchema.optional(),
-  displayName: z.string().optional(),
-  sensitive: z.boolean().optional(),
-  url: z.string().optional(),
-  complementaryTo: z.string().optional(),
-})
-
-export const instanceFileMetaSchema = z.object({
-  name: z.string(),
-  contentType: z.string(),
-  size: z.number(),
-  isBinary: z.boolean().optional(),
-})
-
-export const instanceFileSchema = z.object({
-  meta: instanceFileMetaSchema,
-  content: z.string(),
-})
-
-export const instancePageBlockSchema = z.union([
-  z.object({
-    type: z.literal("markdown"),
-    content: z.string(),
-  }),
-  z.object({
-    type: z.literal("qr"),
-    content: z.string(),
-    showContent: z.coerce.boolean(),
-    language: z.string().optional(),
-  }),
-  z.object({
-    type: z.literal("file"),
-    fileMeta: instanceFileMetaSchema,
-  }),
-])
-
-export const instancePageMetaSchema = z.object({
-  name: z.string(),
-  title: z.string(),
-})
-
-export const instancePageSchema = z.object({
-  ...instancePageMetaSchema.shape,
-  content: z.array(instancePageBlockSchema),
-})
-
-export const instanceTerminalMetaSchema = z.object({
-  name: z.string(),
-  title: z.string(),
-  description: z.string().optional(),
-})
-
-export const instanceTerminalFileSchema = z.object({
-  content: z.string().optional(),
-  isBinary: z.boolean().optional(),
-  mode: z.number().optional(),
-})
-
-export const instanceTerminalSchema = z.object({
-  ...instanceTerminalMetaSchema.shape,
-  image: z.string(),
-  command: z.string().array(),
-  cwd: z.string().optional(),
-  env: z.record(z.string()).optional(),
-  files: z.record(instanceTerminalFileSchema).optional(),
-})
-
-export const instanceTriggerSpecSchema = z.union([
-  z.object({
-    type: z.literal("before-destroy"),
-  }),
-  z.object({
-    type: z.literal("schedule"),
-    schedule: z.string(),
-  }),
-])
-
-export const instanceTriggerSchema = z.object({
-  name: z.string(),
-  title: z.string(),
-  description: z.string().optional(),
-  spec: instanceTriggerSpecSchema,
-})
-
-export const instanceTriggerInvocationSchema = z.object({
-  name: z.string(),
-})
-
-export const instanceStateSchema = z.object({
-  id: z.string(),
-  parentId: z.string().nullable().default(null),
-  status: instanceStatusSchema,
-  dependencyIds: z.array(z.string()).default(() => []),
-
-  latestOperationId: z.string().nullable().default(null),
-
-  currentResourceCount: z.number().nullable().default(null),
-  totalResourceCount: z.number().nullable().default(null),
-  inputHash: z.string().nullable().default(null),
-  outputHash: z.string().nullable().default(null),
-
-  error: z.string().nullable().default(null),
-  evaluationError: z.string().nullable().default(null),
-
-  statusFields: z.array(instanceStatusFieldSchema).default(() => []),
-  files: z.array(instanceFileMetaSchema).default(() => []),
-  pages: z.array(instancePageMetaSchema).default(() => []),
-  terminals: z.array(instanceTerminalMetaSchema).default(() => []),
-  triggers: z.array(instanceTriggerSchema).default(() => []),
-})
-
-export const instanceStateUpdateSchema = z
-  .object({
-    ...instanceStateSchema.shape,
-
-    // secrets updated by the unit
-    secrets: z.record(z.string()).nullable(),
-
-    // log line emitted by the unit
-    logLine: z.string().nullable(),
-  })
-  .partial()
-
-export type InstanceStatusFieldValue = z.infer<typeof instanceStatusFieldValueSchema>
-export type InstanceStatusField = z.infer<typeof instanceStatusFieldSchema>
-export type InstanceTerminal = z.infer<typeof instanceTerminalSchema>
-
-export type InstanceStatus = z.infer<typeof instanceStatusSchema>
-export type InstanceState = z.infer<typeof instanceStateSchema>
-
-export type InstanceStateUpdate = z.infer<typeof instanceStateUpdateSchema>
-
-export type InstancePageBlock = z.infer<typeof instancePageBlockSchema>
-export type InstancePageMeta = z.infer<typeof instancePageMetaSchema>
-export type InstanceFileMeta = z.infer<typeof instanceFileMetaSchema>
-
-export type InstanceTriggerSpec = z.infer<typeof instanceTriggerSpecSchema>
-export type InstanceTrigger = z.infer<typeof instanceTriggerSchema>
-export type InstanceTriggerInvocation = z.infer<typeof instanceTriggerInvocationSchema>
-
-export function createInstanceState(
-  id: string,
-  status: InstanceStatus = "not_created",
-  fields: Partial<InstanceState> = {},
-): InstanceState {
-  return {
-    id,
-    parentId: null,
-    dependencyIds: [],
-    status: status,
-
-    latestOperationId: null,
-
-    currentResourceCount: null,
-    totalResourceCount: null,
-    inputHash: null,
-    outputHash: null,
-
-    error: null,
-    evaluationError: null,
-
-    statusFields: [],
-    files: [],
-    pages: [],
-    terminals: [],
-    triggers: [],
-
-    ...fields,
-  }
-}
-
-export function applyPartialInstanceState(
-  states: Map<string, InstanceState>,
-  patch: Partial<InstanceState>,
-): InstanceState {
-  if (!patch.id) {
-    throw new Error("The ID of the instance state is required.")
-  }
-
-  let state = states.get(patch.id) ?? createInstanceState(patch.id, "unknown")
-  state = { ...state, ...patch }
-
-  states.set(state.id, state)
-  return state
-}
-
-export function createInstanceStatePatch(update: InstanceStateUpdate): Partial<InstanceState> {
-  return omit(update, ["secrets", "logLine"])
-}
-
-/**
- * Builds a map where instance id -> instance state ids that directly depend on the instance.
- *
- * @param instanceStates The instance states to build the map from.
- */
-export function buildDependentInstanceStateMap(
-  instanceStates: Map<string, InstanceState>,
-): Map<string, string[]> {
-  const dependentMap = new Map<string, string[]>()
-
-  for (const state of instanceStates.values()) {
-    for (const dependency of state.dependencyIds) {
-      let dependents = dependentMap.get(dependency)
-      if (!dependents) {
-        dependents = []
-        dependentMap.set(dependency, dependents)
-      }
-
-      dependents.push(state.id)
-    }
-  }
-
-  return dependentMap
-}
-
-/**
- * Gets all instance ids that depend on the given instance id (including recursively).
- * The instance id itself is not included in the result.
- *
- * @param dependentMap The dependent map.
- * @param instanceId The instance id to get all dependent instance ids.
- */
-export function getAllDependentInstanceIds(
-  dependentMap: Map<string, string[]>,
-  instanceId: string,
-): string[] {
-  const result = new Set<string>()
-  const visited = new Set<string>()
-
-  const traverse = (id: string) => {
-    if (visited.has(id)) return
-    visited.add(id)
-
-    const dependents = dependentMap.get(id)
-    if (!dependents) return
-
-    for (const dependent of dependents) {
-      result.add(dependent)
-      traverse(dependent)
-    }
-  }
-
-  traverse(instanceId)
-
-  return Array.from(result)
-}

package/src/shared/terminal.ts

@@ -1,13 +0,0 @@
-import { z } from "zod"
-
-export const terminalSessionSchema = z.object({
-  id: z.string().nanoid(),
-  projectId: z.string(),
-  instanceId: z.string(),
-  terminalName: z.string(),
-  terminalTitle: z.string(),
-  createdAt: z.coerce.date(),
-  finishedAt: z.coerce.date().optional(),
-})
-
-export type TerminalSession = z.infer<typeof terminalSessionSchema>