@highstate/contract 0.21.1 → 0.27.0

package/dist/index.js

@@ -256,6 +256,22 @@ function isEntityIncludeRef(value) {
   const entity = value.entity;
   return typeof entity === "function" || isEntity(entity);
 }
+var objectEntity = {
+  type: "system.object.v1",
+  schema: z2.object().loose(),
+  model: {
+    type: "system.object.v1",
+    definitionHash: 0,
+    schema: z2.object().loose().toJSONSchema(),
+    meta: {
+      title: "Object",
+      description: "The common ancestor of all entities. Any entity can be assigned to this entity.",
+      color: "#9e9e9e",
+      icon: "mdi:cube",
+      iconColor: "#9e9e9e"
+    }
+  }
+};
 function defineEntity(options) {
   try {
     entityModelSchema.shape.type.parse(options.type);
@@ -292,28 +308,47 @@ function defineEntity(options) {
     shape[includeRef.field] = schema;
     return shape;
   }, {});
-  let finalSchema = Object.values(options.extends ?? {}).reduce((schema, entity) => z2.intersection(schema, entity.schema), options.schema);
+  const inheritedExtensions = [...Object.values(options.extends ?? {}), objectEntity].filter((entity) => entity.type !== options.type);
+  const uniqueExtensions = Array.from(new Map(inheritedExtensions.map((entity) => [entity.type, entity])).values());
+  const schemaExtensions = uniqueExtensions.filter((entity) => entity.type !== objectEntity.type);
+  const strictIntersectionBase = (schema) => {
+    if (schema instanceof z2.ZodObject) {
+      return schema.strict();
+    }
+    return schema;
+  };
+  let finalSchema = schemaExtensions.reduce((schema, entity) => z2.intersection(schema, strictIntersectionBase(entity.schema)), strictIntersectionBase(options.schema));
   if (includeRefs.length > 0) {
-    finalSchema = z2.intersection(finalSchema, z2.object(inclusionShape));
+    finalSchema = z2.intersection(finalSchema, strictIntersectionBase(z2.object(inclusionShape)));
+  }
+  finalSchema = z2.intersection(finalSchema, strictIntersectionBase(entityWithMetaSchema));
+  const optionalMultipleInclusions = includeRefs.filter((includeRef) => includeRef.multiple && !includeRef.required);
+  if (optionalMultipleInclusions.length > 0) {
+    finalSchema = finalSchema.overwrite((value) => {
+      const record = value;
+      for (const inclusion of optionalMultipleInclusions) {
+        record[inclusion.field] ??= [];
+      }
+      return value;
+    });
   }
-  finalSchema = z2.intersection(finalSchema, entityWithMetaSchema);
   const directInclusions = () => includeRefs.map((includeRef) => ({
     type: includeRef.getEntity().type,
     required: includeRef.required,
     multiple: includeRef.multiple,
     field: includeRef.field
   }));
-  const directExtensions = Object.values(options.extends ?? {}).map((entity) => entity.type);
+  const directExtensions = uniqueExtensions.map((entity) => entity.type);
   const getInclusions = () => {
     const incs = [...directInclusions()];
-    for (const entity of Object.values(options.extends ?? {})) {
+    for (const entity of uniqueExtensions) {
       if (entity.model.inclusions) {
         incs.push(...entity.model.inclusions);
       }
     }
     return incs;
   };
-  const extensions = Object.values(options.extends ?? {}).reduce((exts, entity) => {
+  const extensions = uniqueExtensions.reduce((exts, entity) => {
     exts.push(...entity.model.extensions ?? [], entity.type);
     return exts;
   }, []);
@@ -1416,9 +1451,65 @@ var unitWorkerSchema = z11.object({
 var workerRunOptionsSchema = z11.object({
   projectId: z11.cuid2(),
   workerVersionId: z11.cuid2(),
+  workerInstanceId: z11.cuid2(),
   apiUrl: z11.url(),
+  dataEndpoint: z11.string().min(1),
   apiKey: z11.string()
 });
+// src/runtime.ts
+import { z as z12 } from "zod";
+var runtimeConfigGetInputSchema = z12.void();
+var runtimeConfigGetOutputSchema = unitConfigSchema;
+var runtimeResultSubmitInputSchema = z12.record(z12.string(), z12.unknown());
+var runtimeResultSubmitOutputSchema = z12.object({});
+var runtimeSidecarFileSchema = z12.object({
+  path: z12.string(),
+  content: z12.string(),
+  secret: z12.boolean().default(false),
+  mode: z12.number().int().optional()
+});
+var runtimeSidecarPortSchema = z12.object({
+  name: z12.string(),
+  containerPort: z12.number().int().positive().max(65535),
+  protocol: z12.literal("tcp").default("tcp")
+});
+var runtimeSidecarReadinessSchema = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal("tcp"),
+    port: z12.string(),
+    timeoutSeconds: z12.number().int().positive().default(30)
+  }),
+  z12.object({
+    type: z12.literal("http"),
+    port: z12.string(),
+    path: z12.string(),
+    statuses: z12.number().int().positive().array().default([200]),
+    timeoutSeconds: z12.number().int().positive().default(30)
+  }),
+  z12.object({
+    type: z12.literal("log"),
+    pattern: z12.string(),
+    timeoutSeconds: z12.number().int().positive().default(30)
+  })
+]);
+var runtimeSidecarStartInputSchema = z12.object({
+  identity: z12.string().regex(/^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/),
+  image: z12.string(),
+  command: z12.string().array().optional(),
+  args: z12.string().array().default([]),
+  env: z12.record(z12.string(), z12.string()).default({}),
+  files: runtimeSidecarFileSchema.array().default([]),
+  ports: runtimeSidecarPortSchema.array().default([]),
+  readiness: runtimeSidecarReadinessSchema.optional()
+});
+var runtimeSidecarStartOutputSchema = z12.object({
+  id: z12.string(),
+  host: z12.string(),
+  ports: z12.record(z12.string(), z12.object({
+    host: z12.string(),
+    port: z12.number().int().positive().max(65535)
+  }))
+});
 // src/utils.ts
 import { isNonNullish as isNonNullish2, pickBy as pickBy2 } from "remeda";
 function text(strings, ...values) {
@@ -1469,9 +1560,9 @@ function stripNullish(obj) {
 }
 
 // src/index.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 export {
-  z12 as z,
+  z13 as z,
   yamlValueSchema,
   workerRunOptionsSchema,
   versionedNameSchema,
@@ -1497,7 +1588,16 @@ export {
   serviceAccountMetaSchema,
   selectInput,
   secretSchema,
+  runtimeSidecarStartOutputSchema,
+  runtimeSidecarStartInputSchema,
+  runtimeSidecarReadinessSchema,
+  runtimeSidecarPortSchema,
+  runtimeSidecarFileSchema,
   runtimeSchema,
+  runtimeResultSubmitOutputSchema,
+  runtimeResultSubmitInputSchema,
+  runtimeConfigGetOutputSchema,
+  runtimeConfigGetInputSchema,
   resetEvaluation,
   registerKnownAbbreviations,
   positionSchema,
@@ -1507,6 +1607,7 @@ export {
   pageBlockSchema,
   originalCreate,
   objectMetaSchema,
+  objectEntity,
   kind,
   isUnitModel,
   isSecret,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/contract",
-  "version": "0.21.1",
+  "version": "0.27.0",
   "type": "module",
   "files": [
     "dist",

package/src/component.spec.ts

@@ -190,6 +190,17 @@ describe("defineComponent", () => {
       },
     ])
 
+    expect(
+      server.schema.parse({
+        $meta: {
+          type: "common.server.v1",
+          identity: "server-1",
+        },
+        tag: "prod",
+        endpoint: "127.0.0.1",
+      }).resource,
+    ).toEqual([])
+
     expect(
       server.schema.safeParse({
         $meta: {

package/src/entity.ts

@@ -383,6 +383,37 @@ type AddSchemaInclusions<
   ? TSchema
   : z.ZodIntersection<TSchema, z.ZodObject<InclusionShape<TImplements>>>
 
+/**
+ * The common ancestor of all entities. Any entity can be assigned to this entity.
+ */
+export const objectEntity = {
+  type: "system.object.v1",
+  schema: z.object().loose(),
+  model: {
+    type: "system.object.v1",
+    definitionHash: 0,
+    schema: z.object().loose().toJSONSchema(),
+    meta: {
+      title: "Object",
+      description:
+        "The common ancestor of all entities. Any entity can be assigned to this entity.",
+      color: "#9e9e9e",
+      icon: "mdi:cube",
+      iconColor: "#9e9e9e",
+    },
+  },
+} as unknown as Entity<"system.object.v1", { "system.object.v1": true }, z.ZodUnknown>
+
+type DefineEntityTypeExtensions<
+  TImplementedTypes extends EntityTypes,
+  TExtends extends Record<string, Entity>,
+> = AddTypeExtensions<TImplementedTypes, TExtends> & (typeof objectEntity)[typeof implementedTypes]
+
+type DefineEntitySchemaExtensions<
+  TSchema extends z.ZodTypeAny,
+  TExtends extends Record<string, Entity>,
+> = AddSchemaExtensions<TSchema, TExtends>
+
 export function defineEntity<
   TType extends VersionedName,
   TSchema extends z.ZodType,
@@ -392,8 +423,8 @@ export function defineEntity<
   options: EntityOptions<TType, TSchema, TExtends, TIncludes>,
 ): Entity<
   TType,
-  Simplify<AddTypeExtensions<{ [K in TType]: true }, TExtends>>,
-  MakeEntitySchema<AddSchemaExtensions<AddSchemaInclusions<TSchema, TIncludes>, TExtends>>,
+  DefineEntityTypeExtensions<{ [K in TType]: true }, TExtends>,
+  MakeEntitySchema<DefineEntitySchemaExtensions<AddSchemaInclusions<TSchema, TIncludes>, TExtends>>,
   DefineEntityValue<TSchema, TExtends, AddIncludeExtensions<TIncludes, TExtends>>,
   DefineEntityInput<TSchema, TExtends, AddIncludeExtensions<TIncludes, TExtends>>,
   AddIncludeExtensions<TIncludes, TExtends>
@@ -455,16 +486,49 @@ export function defineEntity<
     {} as Record<string, z.ZodTypeAny>,
   )
 
-  let finalSchema = Object.values(options.extends ?? {}).reduce(
-    (schema, entity) => z.intersection(schema, entity.schema),
-    options.schema as z.ZodType,
+  const inheritedExtensions = [...Object.values(options.extends ?? {}), objectEntity].filter(
+    entity => entity.type !== options.type,
+  )
+
+  const uniqueExtensions = Array.from(
+    new Map(inheritedExtensions.map(entity => [entity.type, entity])).values(),
+  )
+
+  const schemaExtensions = uniqueExtensions.filter(entity => entity.type !== objectEntity.type)
+
+  const strictIntersectionBase = (schema: z.ZodTypeAny): z.ZodTypeAny => {
+    if (schema instanceof z.ZodObject) {
+      return schema.strict()
+    }
+
+    return schema
+  }
+
+  let finalSchema = schemaExtensions.reduce(
+    (schema, entity) => z.intersection(schema, strictIntersectionBase(entity.schema)),
+    strictIntersectionBase(options.schema as z.ZodTypeAny),
   )
 
   if (includeRefs.length > 0) {
-    finalSchema = z.intersection(finalSchema, z.object(inclusionShape))
+    finalSchema = z.intersection(finalSchema, strictIntersectionBase(z.object(inclusionShape)))
   }
 
-  finalSchema = z.intersection(finalSchema, entityWithMetaSchema)
+  finalSchema = z.intersection(finalSchema, strictIntersectionBase(entityWithMetaSchema))
+
+  const optionalMultipleInclusions = includeRefs.filter(
+    includeRef => includeRef.multiple && !includeRef.required,
+  )
+  if (optionalMultipleInclusions.length > 0) {
+    finalSchema = finalSchema.overwrite(value => {
+      const record = value as Record<string, unknown>
+
+      for (const inclusion of optionalMultipleInclusions) {
+        record[inclusion.field] ??= []
+      }
+
+      return value
+    })
+  }
 
   const directInclusions = () =>
     includeRefs.map(includeRef => ({
@@ -473,12 +537,12 @@ export function defineEntity<
       multiple: includeRef.multiple,
       field: includeRef.field,
     }))
-  const directExtensions = Object.values(options.extends ?? {}).map(entity => entity.type)
+  const directExtensions = uniqueExtensions.map(entity => entity.type)
 
   const getInclusions = () => {
     const incs = [...directInclusions()]
 
-    for (const entity of Object.values(options.extends ?? {})) {
+    for (const entity of uniqueExtensions) {
       if (entity.model.inclusions) {
         incs.push(...entity.model.inclusions)
       }
@@ -487,7 +551,7 @@ export function defineEntity<
     return incs
   }
 
-  const extensions = Object.values(options.extends ?? {}).reduce((exts, entity) => {
+  const extensions = uniqueExtensions.reduce((exts, entity) => {
     exts.push(...(entity.model.extensions ?? []), entity.type)
 
     return exts

package/src/index.ts

@@ -12,6 +12,7 @@ export {
   defineEntity,
   entityModelSchema,
   getEntityId,
+  objectEntity,
 } from "./entity"
 
 export * from "./instance"
@@ -23,6 +24,7 @@ export * from "./terminal"
 export * from "./page"
 export * from "./trigger"
 export * from "./worker"
+export * from "./runtime"
 export * from "./cuidv2d"
 
 export {

package/src/runtime.ts

@@ -0,0 +1,74 @@
+import { z } from "zod"
+import { unitConfigSchema } from "./pulumi"
+
+export const runtimeConfigGetInputSchema = z.void()
+
+export const runtimeConfigGetOutputSchema = unitConfigSchema
+
+export const runtimeResultSubmitInputSchema = z.record(z.string(), z.unknown())
+
+export const runtimeResultSubmitOutputSchema = z.object({})
+
+export const runtimeSidecarFileSchema = z.object({
+  path: z.string(),
+  content: z.string(),
+  secret: z.boolean().default(false),
+  mode: z.number().int().optional(),
+})
+
+export const runtimeSidecarPortSchema = z.object({
+  name: z.string(),
+  containerPort: z.number().int().positive().max(65535),
+  protocol: z.literal("tcp").default("tcp"),
+})
+
+export const runtimeSidecarReadinessSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("tcp"),
+    port: z.string(),
+    timeoutSeconds: z.number().int().positive().default(30),
+  }),
+  z.object({
+    type: z.literal("http"),
+    port: z.string(),
+    path: z.string(),
+    statuses: z.number().int().positive().array().default([200]),
+    timeoutSeconds: z.number().int().positive().default(30),
+  }),
+  z.object({
+    type: z.literal("log"),
+    pattern: z.string(),
+    timeoutSeconds: z.number().int().positive().default(30),
+  }),
+])
+
+export const runtimeSidecarStartInputSchema = z.object({
+  identity: z.string().regex(/^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/),
+  image: z.string(),
+  command: z.string().array().optional(),
+  args: z.string().array().default([]),
+  env: z.record(z.string(), z.string()).default({}),
+  files: runtimeSidecarFileSchema.array().default([]),
+  ports: runtimeSidecarPortSchema.array().default([]),
+  readiness: runtimeSidecarReadinessSchema.optional(),
+})
+
+export const runtimeSidecarStartOutputSchema = z.object({
+  id: z.string(),
+  host: z.string(),
+  ports: z.record(
+    z.string(),
+    z.object({
+      host: z.string(),
+      port: z.number().int().positive().max(65535),
+    }),
+  ),
+})
+
+export type RuntimeConfigGetInput = z.infer<typeof runtimeConfigGetInputSchema>
+export type RuntimeConfigGetOutput = z.infer<typeof runtimeConfigGetOutputSchema>
+export type RuntimeResultSubmitInput = z.infer<typeof runtimeResultSubmitInputSchema>
+export type RuntimeResultSubmitOutput = z.infer<typeof runtimeResultSubmitOutputSchema>
+export type RuntimeSidecarReadiness = z.infer<typeof runtimeSidecarReadinessSchema>
+export type RuntimeSidecarStartInput = z.infer<typeof runtimeSidecarStartInputSchema>
+export type RuntimeSidecarStartOutput = z.infer<typeof runtimeSidecarStartOutputSchema>

package/src/worker.ts

@@ -19,11 +19,21 @@ export const workerRunOptionsSchema = z.object({
    */
   workerVersionId: z.cuid2(),
 
+  /**
+   * The ID of the concrete worker instance.
+   */
+  workerInstanceId: z.cuid2(),
+
   /**
    * The URL of the backend API to connect to.
    */
   apiUrl: z.url(),
 
+  /**
+   * The host and port of the worker data endpoint reachable by the frontend gateway.
+   */
+  dataEndpoint: z.string().min(1),
+
   /**
    * The API key used to authenticate the worker with the backend.
    */