@highstate/library 0.9.16 → 0.9.18

package/src/network.ts

@@ -1,48 +1,48 @@
-import { defineEntity, defineUnit, Type, type Static } from "@highstate/contract"
+import { defineEntity, defineUnit, z } from "@highstate/contract"
 
-export const endpointVisibilitySchema = Type.StringEnum([
+export const endpointVisibilitySchema = z.enum([
   "public", // Reachable from the public internet
   "external", // Reachable from outside the system boundary, but not public
   "internal", // Reachable only from within the system or cluster
 ])
 
-export const endpointFilterSchema = Type.Array(endpointVisibilitySchema)
+export const endpointFilterSchema = endpointVisibilitySchema.array()
 
 export const l3EndpointEntity = defineEntity({
   type: "network.l3-endpoint",
 
-  schema: Type.Intersect([
-    Type.Object({
+  schema: z.intersection(
+    z.object({
       visibility: endpointVisibilitySchema,
-      metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+      metadata: z.record(z.string(), z.unknown()).optional(),
     }),
-    Type.Union([
-      Type.Object({
-        type: Type.Literal("hostname"),
+    z.union([
+      z.object({
+        type: z.literal("hostname"),
 
         /**
          * The hostname of the endpoint in the format of a domain name.
          */
-        hostname: Type.String(),
+        hostname: z.string(),
       }),
-      Type.Object({
-        type: Type.Literal("ipv4"),
+      z.object({
+        type: z.literal("ipv4"),
 
         /**
          * The IPv4 address of the endpoint.
          */
-        address: Type.String(),
+        address: z.string(),
       }),
-      Type.Object({
-        type: Type.Literal("ipv6"),
+      z.object({
+        type: z.literal("ipv6"),
 
         /**
          * The IPv6 address of the endpoint.
          */
-        address: Type.String(),
+        address: z.string(),
       }),
     ]),
-  ]),
+  ),
 
   meta: {
     color: "#4CAF50",
@@ -50,17 +50,17 @@ export const l3EndpointEntity = defineEntity({
   },
 })
 
-export const l4ProtocolSchema = Type.StringEnum(["tcp", "udp"])
+export const l4ProtocolSchema = z.enum(["tcp", "udp"])
 
-export const l4PortInfoSchema = Type.Object({
-  port: Type.Number(),
+export const l4PortInfoSchema = z.object({
+  port: z.number(),
   protocol: l4ProtocolSchema,
 })
 
 export const l4EndpointEntity = defineEntity({
   type: "network.l4-endpoint",
 
-  schema: Type.Intersect([l3EndpointEntity.schema, l4PortInfoSchema]),
+  schema: z.intersection(l3EndpointEntity.schema, l4PortInfoSchema),
 
   meta: {
     color: "#2196F3",
@@ -68,11 +68,11 @@ export const l4EndpointEntity = defineEntity({
   },
 })
 
-export const l7AppInfoSchema = Type.Object({
+export const l7AppInfoSchema = z.object({
   /**
    * The name of the application protocol used by the endpoint.
    */
-  appProtocol: Type.String(),
+  appProtocol: z.string(),
 
   /**
    * The resource path of the application endpoint, including query parameters.
@@ -80,13 +80,13 @@ export const l7AppInfoSchema = Type.Object({
    *
    * Example: `api/v1/resource?query=value`, `database?param=value`, `user/repo.git`.
    */
-  resource: Type.Optional(Type.String()),
+  resource: z.string().optional(),
 })
 
 export const l7EndpointEntity = defineEntity({
   type: "network.l7-endpoint",
 
-  schema: Type.Intersect([l4EndpointEntity.schema, l7AppInfoSchema]),
+  schema: z.intersection(l4EndpointEntity.schema, l7AppInfoSchema),
 
   meta: {
     color: "#FF9800",
@@ -104,12 +104,12 @@ export const l3Endpoint = defineUnit({
      *
      * May be a domain name or an IP address.
      */
-    endpoint: Type.String(),
+    endpoint: z.string(),
 
     /**
      * The visibility of the endpoint.
      */
-    visibility: Type.Default(endpointVisibilitySchema, "public"),
+    visibility: endpointVisibilitySchema.default("public"),
   },
 
   outputs: {
@@ -117,10 +117,10 @@ export const l3Endpoint = defineUnit({
   },
 
   meta: {
-    displayName: "L3 Endpoint",
+    title: "L3 Endpoint",
     description: "An L3 endpoint for some service. May be a domain name or an IP address.",
-    primaryIcon: "mdi:network-outline",
-    primaryIconColor: "#4CAF50",
+    icon: "mdi:network-outline",
+    iconColor: "#4CAF50",
     defaultNamePrefix: "endpoint",
     category: "Network",
   },
@@ -146,12 +146,12 @@ export const l4Endpoint = defineUnit({
      * - `tcp://endpoint:port`
      * - `udp://endpoint:port`
      */
-    endpoint: Type.String(),
+    endpoint: z.string(),
 
     /**
      * The visibility of the endpoint.
      */
-    visibility: Type.Default(endpointVisibilitySchema, "public"),
+    visibility: endpointVisibilitySchema.default("public"),
   },
 
   outputs: {
@@ -159,10 +159,10 @@ export const l4Endpoint = defineUnit({
   },
 
   meta: {
-    displayName: "L4 Endpoint",
+    title: "L4 Endpoint",
     description: "An L4 endpoint for some service. Extends an L3 endpoint with a port.",
-    primaryIcon: "mdi:network-outline",
-    primaryIconColor: "#2196F3",
+    icon: "mdi:network-outline",
+    iconColor: "#2196F3",
     defaultNamePrefix: "endpoint",
     category: "Network",
   },
@@ -180,7 +180,7 @@ export const l4Endpoint = defineUnit({
  * - `external`: Reachable from outside the system boundary (e.g., LAN, VPC), but not public.
  * - `internal`: Reachable only from within the application or infrastructure boundary (e.g., within a cluster).
  */
-export type EndpointVisibility = Static<typeof endpointVisibilitySchema>
+export type EndpointVisibility = z.infer<typeof endpointVisibilitySchema>
 
 /**
  * The list of endpoint visibility levels used to filter endpoints.
@@ -190,14 +190,14 @@ export type EndpointVisibility = Static<typeof endpointVisibilitySchema>
  *   - Otherwise, if any external endpoints exist, all external endpoints are selected.
  *   - If neither exist, all internal endpoints are selected.
  */
-export type EndpointFilter = Static<typeof endpointFilterSchema>
-
-export type L3Endpoint = Static<typeof l3EndpointEntity.schema>
-export type L4Endpoint = Static<typeof l4EndpointEntity.schema>
-export type L4Protocol = Static<typeof l4ProtocolSchema>
-export type L4PortInfo = Static<typeof l4PortInfoSchema>
-export type L7Endpoint = Static<typeof l7EndpointEntity.schema>
-export type L7AppInfo = Static<typeof l7AppInfoSchema>
+export type EndpointFilter = z.infer<typeof endpointFilterSchema>
+
+export type L3Endpoint = z.infer<typeof l3EndpointEntity.schema>
+export type L4Endpoint = z.infer<typeof l4EndpointEntity.schema>
+export type L4Protocol = z.infer<typeof l4ProtocolSchema>
+export type L4PortInfo = z.infer<typeof l4PortInfoSchema>
+export type L7Endpoint = z.infer<typeof l7EndpointEntity.schema>
+export type L7AppInfo = z.infer<typeof l7AppInfoSchema>
 
 /**
  * The L3 or L4 endpoint for some service.

package/src/nixos.ts

@@ -1,33 +1,7 @@
-import { defineUnit, Type } from "@highstate/contract"
+import { defineUnit, z } from "@highstate/contract"
 import { fileEntity, folderEntity } from "./files"
 import { serverEntity } from "./common"
 
-// export const moduleEntity = defineEntity({
-//   type: "nixos.module",
-
-//   schema: Type.Object({
-//     /**
-//      * The folder containing the NixOS module files.
-//      *
-//      * @schema
-//      */
-//     folder: folderEntity.schema,
-
-//     /**
-//      * The name of the module file entrypoint to use when importing this module.
-//      *
-//      * @schema
-//      */
-//     entrypoint: Type.String(),
-//   }),
-
-//   meta: {
-//     displayName: "NixOS Module",
-//     description: "The NixOS module reference.",
-//     color: "#5277c3",
-//   },
-// })
-
 export const inlineModule = defineUnit({
   type: "nixos.inline-module",
 
@@ -37,14 +11,14 @@ export const inlineModule = defineUnit({
      *
      * If not provided, the name will be the name of the unit.
      */
-    moduleName: Type.Optional(Type.String()),
+    moduleName: z.string().optional(),
 
     /**
      * The code of the NixOS module.
      *
      * In this code you can reference other modules and files by their names.
      */
-    code: Type.String({ language: "nix" }),
+    code: z.string().meta({ language: "nix" }),
   },
 
   inputs: {
@@ -65,10 +39,10 @@ export const inlineModule = defineUnit({
   },
 
   meta: {
-    displayName: "NixOS Inline Module",
+    title: "NixOS Inline Module",
     description: "Creates a NixOS module from inline code.",
-    primaryIcon: "simple-icons:nixos",
-    primaryIconColor: "#7ebae4",
+    icon: "simple-icons:nixos",
+    iconColor: "#7ebae4",
     secondaryIcon: "mdi:file-code",
     category: "NixOS",
   },
@@ -79,34 +53,6 @@ export const inlineModule = defineUnit({
   },
 })
 
-// export const flakeEntity = defineEntity({
-//   type: "nixos.flake",
-
-//   schema: Type.Object({
-//     /**
-//      * The git repository where the flake is stored.
-//      *
-//      * @schema
-//      */
-//     repository: repositoryEntity.schema,
-
-//     /**
-//      * The relative path to the folder containing the flake.nix file.
-//      *
-//      * If not provided, the root of the repository will be used.
-//      *
-//      * @schema
-//      */
-//     flakePath: Type.Optional(Type.String()),
-//   }),
-
-//   meta: {
-//     displayName: "NixOS Flake",
-//     description: "The NixOS flake reference.",
-//     color: "#5277c3",
-//   },
-// })
-
 export const inlineFlake = defineUnit({
   type: "nixos.inline-flake",
 
@@ -116,14 +62,14 @@ export const inlineFlake = defineUnit({
      *
      * If not provided, the name will be the name of the unit.
      */
-    flakeName: Type.Optional(Type.String()),
+    flakeName: z.string().optional(),
 
     /**
      * The code of the `flake.nix` file.
      *
      * In this code you can reference other flakes, modules, files, and folders by their names.
      */
-    code: Type.String({ language: "nix" }),
+    code: z.string().meta({ language: "nix" }),
   },
 
   inputs: {
@@ -144,10 +90,10 @@ export const inlineFlake = defineUnit({
   },
 
   meta: {
-    displayName: "NixOS Inline Flake",
+    title: "NixOS Inline Flake",
     description: "Creates a NixOS flake from inline code.",
-    primaryIcon: "simple-icons:nixos",
-    primaryIconColor: "#7ebae4",
+    icon: "simple-icons:nixos",
+    iconColor: "#7ebae4",
     secondaryIcon: "mdi:file-code",
     category: "NixOS",
   },
@@ -162,7 +108,7 @@ export const system = defineUnit({
   type: "nixos.system",
 
   args: {
-    system: Type.Optional(Type.String()),
+    system: z.string().optional(),
   },
 
   inputs: {
@@ -175,10 +121,10 @@ export const system = defineUnit({
   },
 
   meta: {
-    displayName: "NixOS System",
+    title: "NixOS System",
     description: "Creates a NixOS system on top of any server.",
-    primaryIcon: "simple-icons:nixos",
-    primaryIconColor: "#7ebae4",
+    icon: "simple-icons:nixos",
+    iconColor: "#7ebae4",
     secondaryIcon: "codicon:vm",
     category: "NixOS",
   },

package/src/obfuscators/phantun.ts

@@ -6,9 +6,9 @@ export const deobfuscator = defineUnit({
   ...deobfuscatorSpec,
 
   meta: {
-    displayName: "Phantun Deobfuscator",
+    title: "Phantun Deobfuscator",
     description: "The Phantun Deobfuscator deployed on Kubernetes.",
-    primaryIcon: "mdi:network-outline",
+    icon: "mdi:network-outline",
     secondaryIcon: "mdi:hide",
     category: "Obfuscators",
   },
@@ -24,9 +24,9 @@ export const obfuscator = defineUnit({
   ...obfuscatorSpec,
 
   meta: {
-    displayName: "Phantun Obfuscator",
+    title: "Phantun Obfuscator",
     description: "The Phantun Obfuscator deployed on Kubernetes.",
-    primaryIcon: "mdi:network-outline",
+    icon: "mdi:network-outline",
     secondaryIcon: "mdi:hide",
     category: "Obfuscators",
   },

package/src/obfuscators/shared.ts

@@ -1,4 +1,4 @@
-import { $args, $inputs, $outputs, Type, type Static, type TObject } from "@highstate/contract"
+import { $args, $inputs, $outputs, z } from "@highstate/contract"
 import { clusterEntity } from "../k8s"
 import { l4EndpointEntity } from "../network"
 
@@ -9,21 +9,21 @@ export const deobfuscatorSpec = {
      *
      * By default, calculated as `deobfs-{type}-{name}`.
      */
-    appName: Type.Optional(Type.String()),
+    appName: z.string().optional(),
 
     /**
      * The L4 endpoint to forward deobfuscated traffic to.
      *
      * Will take precedence over the `targetEndpoint` input.
      */
-    targetEndpoints: Type.Default(Type.Array(Type.String()), []),
+    targetEndpoints: z.string().array().default([]),
 
     /**
      * Whether to expose the deobfuscator service by "NodePort" or "LoadBalancer".
      *
      * By default, the service is not exposed and only accessible from within the cluster.
      */
-    external: Type.Default(Type.Boolean(), false),
+    external: z.boolean().default(false),
   }),
 
   inputs: $inputs({
@@ -63,21 +63,21 @@ export const obfuscatorSpec = {
      *
      * By default, calculated as `obfs-{type}-{name}`.
      */
-    appName: Type.Optional(Type.String()),
+    appName: z.string().optional(),
 
     /**
      * The endpoint of the deobfuscator to pass obfuscated traffic to.
      *
      * Will take precedence over the `endpoint` input.
      */
-    endpoints: Type.Default(Type.Array(Type.String()), []),
+    endpoints: z.string().array().default([]),
 
     /**
      * Whether to expose the obfuscator service by "NodePort" or "LoadBalancer".
      *
      * By default, the service is not exposed and only accessible from within the cluster.
      */
-    external: Type.Default(Type.Boolean(), false),
+    external: z.boolean().default(false),
   }),
 
   inputs: $inputs({
@@ -109,5 +109,5 @@ export const obfuscatorSpec = {
   }),
 }
 
-export type DeobfuscatorArgs = Static<TObject<(typeof deobfuscatorSpec)["args"]>>
-export type ObfuscatorArgs = Static<TObject<(typeof obfuscatorSpec)["args"]>>
+export type DeobfuscatorArgs = z.infer<typeof deobfuscatorSpec.args>
+export type ObfuscatorArgs = z.infer<typeof obfuscatorSpec.args>