@highstate/library 0.19.1 → 0.21.1

package/src/databases/postgresql.ts

@@ -1,22 +1,64 @@
-import { defineEntity, defineUnit, type EntityInput, z } from "@highstate/contract"
-import { l4EndpointEntity } from "../network"
-import { toPatchArgs } from "../utils"
-import { optionalSharedArgs, sharedArgs, sharedInputs, sharedSchema, sharedSecrets } from "./shared"
+import {
+  defineEntity,
+  defineUnit,
+  type EntityInput,
+  type EntityValue,
+  secretSchema,
+  z,
+} from "@highstate/contract"
+import { l4EndpointContainer, l4EndpointEntity } from "../network"
+import { certificateEntity } from "../tls"
+
+export const credentialsSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("password"),
+
+    /**
+     * The username used to authenticate against the database.
+     */
+    username: z.string(),
+
+    /**
+     * The password used to authenticate against the database.
+     */
+    password: secretSchema(z.string()),
+  }),
+])
 
 /**
- * Represents the PostgreSQL database or virtual database behind it.
+ * Represents a connection to a PostgreSQL instance, including the endpoints and credentials.
  */
-export const postgresqlEntity = defineEntity({
-  type: "databases.postgresql.v1",
+export const connectionEntity = defineEntity({
+  type: "postgresql.connection.v1",
+
+  extends: { l4EndpointContainer },
 
   includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true,
+    /**
+     * The TLS certificate of the server if any.
+     */
+    certificate: {
+      entity: certificateEntity,
+      required: false,
     },
   },
 
-  schema: sharedSchema,
+  schema: z.object({
+    /**
+     * Whether SSL is not required to connect to the database.
+     */
+    insecure: z.boolean().default(false),
+
+    /**
+     * The credentials for authenticating to the PostgreSQL instance.
+     */
+    credentials: credentialsSchema,
+
+    /**
+     * The name of the database to operate on.
+     */
+    database: z.string().optional(),
+  }),
 
   meta: {
     color: "#336791",
@@ -24,26 +66,52 @@ export const postgresqlEntity = defineEntity({
 })
 
 /**
- * The existing PostgreSQL database or virtual database behind it.
+ * The existing PostgreSQL connection hosted on a server or a managed service.
  */
-export const existingPostgresql = defineUnit({
-  type: "databases.postgresql.existing.v1",
+export const connection = defineUnit({
+  type: "postgresql.connection.v1",
+
+  args: {
+    /**
+     * The username to authenticate with.
+     */
+    username: z.string(),
+
+    /**
+     * The endpoints to connect to the PostgreSQL instance in form of `host:port`.
+     */
+    endpoints: z.string().array().default([]),
+  },
+
+  inputs: {
+    /**
+     * The endpoints to connect to the PostgreSQL instance.
+     */
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false,
+    },
+  },
 
-  args: sharedArgs,
-  secrets: sharedSecrets,
-  inputs: sharedInputs,
+  secrets: {
+    /**
+     * The password to authenticate with.
+     */
+    password: z.string(),
+  },
 
   outputs: {
-    postgresql: postgresqlEntity,
+    connection: connectionEntity,
   },
 
   source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-postgresql",
+    package: "@highstate/postgresql",
+    path: "units/connection",
   },
 
   meta: {
-    title: "Existing PostgreSQL Database",
+    title: "PostgreSQL Connection",
     icon: "simple-icons:postgresql",
     secondaryIcon: "mdi:database",
     category: "Databases",
@@ -51,44 +119,69 @@ export const existingPostgresql = defineUnit({
 })
 
 /**
- * Patches some properties of the PostgreSQL database and outputs the updated database.
+ * Creates a database in a PostgreSQL instance.
  */
-export const postgresqlPatch = defineUnit({
-  type: "databases.postgresql-patch.v1",
+export const database = defineUnit({
+  type: "postgresql.database.v1",
 
   args: {
-    ...toPatchArgs(optionalSharedArgs),
+    /**
+     * The name of the database.
+     *
+     * If not provided, it will be set to the unit name.
+     */
+    databaseName: z.string().optional(),
 
     /**
-     * The endpoints to connect to the database in form of `host:port`.
+     * The username to create.
      *
-     * If at least one endpoint is provided (either via args or inputs), the existing endpoints
-     * will be replaced completely.
+     * If not provided, it will be set to the database name.
      */
-    endpoints: z.string().array().default([]),
+    username: z.string().optional(),
+
+    /**
+     * The LC_COLLATE setting for the database, which determines the collation order (i.e., how string comparison is performed).
+     */
+    lcCollate: z.string().optional(),
+
+    /**
+     * The LC_CTYPE setting for the database, which determines the character classification (i.e., how characters are categorized and compared).
+     */
+    lcCtype: z.string().optional(),
   },
 
   inputs: {
-    postgresql: postgresqlEntity,
-    ...sharedInputs,
+    /**
+     * The connection to the PostgreSQL instance where the database should be created.
+     */
+    connection: connectionEntity,
   },
 
-  outputs: {
-    postgresql: postgresqlEntity,
+  secrets: {
+    /**
+     * The password of the created user.
+     *
+     * If not provided, a random password will be generated.
+     */
+    password: z.string().optional(),
   },
 
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/postgresql-patch",
+  outputs: {
+    connection: connectionEntity,
   },
 
   meta: {
-    title: "PostgreSQL Patch",
+    title: "PostgreSQL Database",
     icon: "simple-icons:postgresql",
-    secondaryIcon: "fluent:patch-20-filled",
+    secondaryIcon: "mdi:database-plus",
     category: "Databases",
   },
+
+  source: {
+    package: "@highstate/postgresql",
+    path: "units/database",
+  },
 })
 
-export type PostgreSQL = z.infer<typeof postgresqlEntity.schema>
-export type PostgreSQLInput = EntityInput<typeof postgresqlEntity>
+export type Connection = EntityValue<typeof connectionEntity>
+export type ConnectionInput = EntityInput<typeof connectionEntity>

package/src/databases/redis.ts

@@ -1,26 +1,40 @@
-import { defineEntity, defineUnit, type EntityInput, z } from "@highstate/contract"
-import { l4EndpointEntity } from "../network"
-import { toPatchArgs } from "../utils"
-import { optionalSharedArgs, sharedArgs, sharedInputs } from "./shared"
+import {
+  defineEntity,
+  defineUnit,
+  type EntityInput,
+  type EntityValue,
+  secretSchema,
+  z,
+} from "@highstate/contract"
+import { l4EndpointContainer, l4EndpointEntity } from "../network"
+
+export const credentialsSchema = z.object({
+  /**
+   * The username used to authenticate against the database.
+   */
+  username: z.string().optional(),
+
+  /**
+   * The password used to authenticate against the database.
+   */
+  password: secretSchema(z.string()).optional(),
+})
+
+export const databaseNumberSchema = z.number().nonnegative().max(15)
 
 /**
- * Represents the Redis database or virtual database behind it.
+ * Represents a connection to a Redis instance, including the endpoints and credentials.
  */
-export const redisEntity = defineEntity({
-  type: "databases.redis.v1",
+export const connectionEntity = defineEntity({
+  type: "redis.connection.v1",
 
-  includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true,
-    },
-  },
+  extends: { l4EndpointContainer },
 
   schema: z.object({
     /**
-     * The number of the database to use.
+     * The credentials for authenticating to the Redis instance.
      */
-    database: z.number().default(0),
+    credentials: credentialsSchema.optional(),
   }),
 
   meta: {
@@ -29,25 +43,52 @@ export const redisEntity = defineEntity({
 })
 
 /**
- * The existing Redis database or virtual database behind it.
+ * The existing Redis connection hosted on a server or a managed service.
  */
-export const existingRedis = defineUnit({
-  type: "databases.redis.existing.v1",
+export const connection = defineUnit({
+  type: "redis.connection.existing.v1",
 
-  args: sharedArgs,
-  inputs: sharedInputs,
+  args: {
+    /**
+     * The username to authenticate with.
+     */
+    username: z.string().optional(),
+
+    /**
+     * The endpoints to connect to the database in form of `host:port`.
+     */
+    endpoints: z.string().array().default([]),
+  },
+
+  inputs: {
+    /**
+     * The endpoints to connect to the database.
+     */
+    endpoints: {
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false,
+    },
+  },
+
+  secrets: {
+    /**
+     * The password to authenticate with.
+     */
+    password: z.string().optional(),
+  },
 
   outputs: {
-    redis: redisEntity,
+    connection: connectionEntity,
   },
 
   source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-redis",
+    package: "@highstate/redis",
+    path: "units/connection",
   },
 
   meta: {
-    title: "Existing Redis Database",
+    title: "Redis Connection",
     icon: "simple-icons:redis",
     secondaryIcon: "mdi:database",
     category: "Databases",
@@ -55,41 +96,74 @@ export const existingRedis = defineUnit({
 })
 
 /**
- * Patches some properties of the Redis database and outputs the updated database.
+ * Represents a Redis namespace within a database.
+ */
+export const namespaceEntity = defineEntity({
+  type: "redis.namespace.v1",
+
+  extends: { connectionEntity },
+
+  schema: z.object({
+    /**
+     * The number of the database to use.
+     */
+    database: databaseNumberSchema.default(0),
+
+    /**
+     * The prefix of the namespace in the Redis database.
+     */
+    prefix: z.string().optional(),
+  }),
+
+  meta: {
+    color: "#0064bf",
+  },
+})
+
+/**
+ * Creates a Redis namespace within an existing Redis connection.
  */
-export const redisPatch = defineUnit({
-  type: "databases.redis-patch.v1",
+export const namespace = defineUnit({
+  type: "redis.database.v1",
 
   args: {
-    ...toPatchArgs(optionalSharedArgs),
+    /**
+     * The number of the database to use.
+     */
+    database: databaseNumberSchema.default(0),
 
-    endpoints: {
-      ...sharedArgs.endpoints,
-      schema: z.string().array().default([]),
-    },
+    /**
+     * The prefix of the namespace in the Redis database.
+     */
+    prefix: z.string().optional(),
   },
 
   inputs: {
-    redis: redisEntity,
-    ...sharedInputs,
+    /**
+     * The connection to the Redis instance.
+     */
+    connection: connectionEntity,
   },
 
   outputs: {
-    redis: redisEntity,
-  },
-
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/redis-patch",
+    namespace: namespaceEntity,
   },
 
   meta: {
-    title: "Redis Patch",
+    title: "Redis Database",
     icon: "simple-icons:redis",
-    secondaryIcon: "fluent:patch-20-filled",
+    secondaryIcon: "mdi:database",
     category: "Databases",
   },
+
+  source: {
+    package: "@highstate/redis",
+    path: "units/database",
+  },
 })
 
-export type Redis = z.infer<typeof redisEntity.schema>
-export type RedisInput = EntityInput<typeof redisEntity>
+export type Connection = EntityValue<typeof connectionEntity>
+export type ConnectionInput = EntityInput<typeof connectionEntity>
+
+export type Namespace = EntityValue<typeof namespaceEntity>
+export type NamespaceInput = EntityInput<typeof namespaceEntity>

package/src/databases/s3.ts

@@ -1,114 +1,48 @@
-import type { Simplify } from "type-fest"
 import {
-  $args,
-  $inputs,
-  $secrets,
   defineEntity,
   defineUnit,
   type EntityInput,
-  type FullComponentArgumentOptions,
+  type EntityValue,
+  secretSchema,
   z,
 } from "@highstate/contract"
-import { mapValues } from "remeda"
-import { l4EndpointEntity } from "../network"
-import { toPatchArgs } from "../utils"
+import { l4EndpointEntity, l7EndpointContainer } from "../network"
 
-export const s3BucketPolicySchema = z.enum(["none", "download", "upload", "public"])
-
-export const s3BucketSchema = z.object({
-  /**
-   * The name of the bucket.
-   */
-  name: z.string(),
-
-  /**
-   * The optional policy applied to the bucket.
-   */
-  policy: s3BucketPolicySchema.optional(),
-})
-
-const s3Args = $args({
+export const credentialsSchema = z.object({
   /**
-   * The endpoints to connect to the S3-compatible API in form of `host:port`.
+   * The access key used to authenticate against the API.
    */
-  endpoints: z.string().array().min(1),
+  accessKey: secretSchema(z.string()),
 
   /**
-   * The access key used to authenticate against the S3-compatible API.
+   * The secret key used to authenticate against the API.
    */
-  accessKey: z.string(),
-
-  /**
-   * The region associated with the S3-compatible deployment.
-   */
-  region: z.string().optional(),
-
-  /**
-   * The buckets that must exist on the instance.
-   */
-  buckets: s3BucketSchema.array().default([]),
-})
-
-type ToOptionalArgs<T extends Record<string, FullComponentArgumentOptions>> = Simplify<{
-  [K in keyof T]: Simplify<Omit<T[K], "schema"> & { schema: z.ZodOptional<T[K]["schema"]> }>
-}>
-
-const optionalS3Args = mapValues(s3Args, arg => ({
-  ...arg,
-  schema: arg.schema.optional(),
-})) as ToOptionalArgs<typeof s3Args>
-
-const s3Secrets = $secrets({
-  /**
-   * The secret key used to authenticate against the S3-compatible API.
-   */
-  secretKey: z.string(),
-})
-
-const s3Inputs = $inputs({
-  /**
-   * The endpoints to connect to the S3-compatible API.
-   */
-  endpoints: {
-    entity: l4EndpointEntity,
-    multiple: true,
-    required: false,
-  },
+  secretKey: secretSchema(z.string()),
 })
 
 /**
- * Represents an S3-compatible object storage endpoint.
+ * Represents an S3 bucket with credentials and endpoints to access it.
  */
-export const s3Entity = defineEntity({
-  type: "databases.s3.v1",
+export const bucketEntity = defineEntity({
+  type: "s3.bucket.v1",
 
-  includes: {
-    endpoints: {
-      entity: l4EndpointEntity,
-      multiple: true,
-    },
-  },
+  extends: { l7EndpointContainer },
 
   schema: z.object({
     /**
-     * The region associated with the object storage instance.
-     */
-    region: z.string().optional(),
-
-    /**
-     * The access key used to authenticate against the API.
+     * The name of the S3 bucket.
      */
-    accessKey: z.string(),
+    name: z.string(),
 
     /**
-     * The secret key used to authenticate against the API.
+     * The region where the S3 bucket is located.
      */
-    secretKey: z.string(),
+    region: z.string(),
 
     /**
-     * The buckets that must exist on the instance.
+     * The credentials that can be used to access the S3 bucket.
      */
-    buckets: s3BucketSchema.array(),
+    credentials: credentialsSchema,
   }),
 
   meta: {
@@ -117,68 +51,55 @@ export const s3Entity = defineEntity({
 })
 
 /**
- * The existing S3-compatible object storage instance.
+ * The existing S3 bucket hosted on AWS or another S3-compatible service.
  */
-export const existingS3 = defineUnit({
-  type: "databases.s3.existing.v1",
+export const existingBucket = defineUnit({
+  type: "s3.existing-bucket.v1",
 
-  args: s3Args,
-  secrets: s3Secrets,
-  inputs: s3Inputs,
-
-  outputs: {
-    s3: s3Entity,
-  },
+  args: {
+    /**
+     * The name of the existing S3 bucket.
+     */
+    bucketName: z.string(),
 
-  source: {
-    package: "@highstate/common",
-    path: "units/databases/existing-s3",
-  },
+    /**
+     * The region where the existing S3 bucket is located.
+     */
+    region: z.string(),
 
-  meta: {
-    title: "Existing S3-Compatible Storage",
-    icon: "simple-icons:amazons3",
-    secondaryIcon: "mdi:bucket",
-    category: "Databases",
+    /**
+     * The endpoints to connect to the S3 bucket.
+     */
+    endpoints: z.string().array().default([]),
   },
-})
-
-/**
- * Patches some properties of the S3-compatible object storage and outputs the updated storage.
- */
-export const s3Patch = defineUnit({
-  type: "databases.s3-patch.v1",
-
-  args: {
-    ...toPatchArgs(optionalS3Args),
 
+  inputs: {
+    /**
+     * The endpoints to connect to the S3 bucket.
+     */
     endpoints: {
-      ...s3Args.endpoints,
-      schema: z.string().array().default([]),
+      entity: l4EndpointEntity,
+      multiple: true,
+      required: false,
     },
   },
 
-  inputs: {
-    s3: s3Entity,
-    ...s3Inputs,
-  },
-
   outputs: {
-    s3: s3Entity,
+    bucket: bucketEntity,
   },
 
   source: {
     package: "@highstate/common",
-    path: "units/databases/s3-patch",
+    path: "units/databases/existing-s3-bucket",
   },
 
   meta: {
-    title: "S3 Patch",
-    icon: "simple-icons:amazons3",
-    secondaryIcon: "fluent:patch-20-filled",
+    title: "Existing S3 Bucket",
+    icon: "simple-icons:amazonaws",
+    secondaryIcon: "mdi:database",
     category: "Databases",
   },
 })
 
-export type S3 = z.infer<typeof s3Entity.schema>
-export type S3Input = EntityInput<typeof s3Entity>
+export type Bucket = EntityValue<typeof bucketEntity>
+export type BucketInput = EntityInput<typeof bucketEntity>