@highstate/contract 0.1.1 → 0.2.0

package/package.json

@@ -1,24 +1,32 @@
 {
   "name": "@highstate/contract",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
+  "exports": {
+    "import": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.mjs"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "pkgroll",
-    "dev": "pkgroll --watch"
+    "build": "pkgroll --clean-dist",
+    "test": "jest"
   },
   "dependencies": {
-    "zod": "^3.23.8"
+    "@sinclair/typebox": "^0.34.11",
+    "remeda": "^2.17.4"
   },
   "devDependencies": {
+    "jest": "^29.7.0",
     "pkgroll": "^2.5.1"
   },
-  "gitHead": "63cce0eb6a93b6efff80882017271c4a4ba0c4a7"
+  "gitHead": "41f789ef9d6da623923812bba9783c216605495d"
 }

package/dist/index.d.ts

@@ -1,140 +0,0 @@
-import { z, ZodType, ZodObject } from 'zod';
-
-type StackDependency = Readonly<{
-    project: string;
-    stack: string;
-}>;
-type StackRegistration = Readonly<{
-    project: string;
-    stack: string;
-    config: Readonly<Record<string, unknown>>;
-    secrets: readonly string[];
-    dependencies: readonly StackDependency[];
-}>;
-interface EvaluationContext {
-    registerStack(registration: StackRegistration): void;
-    getSecret(name: string): string | undefined;
-}
-declare function runEvaluation<T>(context: EvaluationContext, fn: () => T): T;
-declare function getCurrentEvaluationContext(): EvaluationContext;
-
-type ListRequiredKeys<T extends Record<string, unknown>> = {
-    [K in keyof T]: undefined extends T[K] ? never : K;
-}[keyof T];
-type PickOptionalRecords<T extends Record<string, Record<string, unknown>>> = {
-    [K in keyof T]: ListRequiredKeys<T[K]> extends never ? K : never;
-}[keyof T];
-type PickRequiredRecords<T extends Record<string, Record<string, unknown>>> = {
-    [K in keyof T]: ListRequiredKeys<T[K]> extends never ? never : K;
-}[keyof T];
-type OptionalEmptyFields<T extends Record<string, Record<string, unknown>>> = {
-    [K in PickOptionalRecords<T>]?: T[K];
-} & {
-    [K in PickRequiredRecords<T>]: T[K];
-};
-
-declare const componentArgType: z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodUndefined]>;
-declare const secretType: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
-declare const inputType: z.ZodObject<{
-    type: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: string;
-}, {
-    type: string;
-}>;
-declare const outputRefType: z.ZodObject<{
-    $output: z.ZodString;
-    project: z.ZodString;
-    stack: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    $output: string;
-    project: string;
-    stack: string;
-}, {
-    $output: string;
-    project: string;
-    stack: string;
-}>;
-type Input<T = unknown> = T extends (infer U)[] ? (U | OutputRef)[] : T | OutputRef;
-type Inputs<T extends Record<string, unknown> = Record<string, unknown>> = {
-    [K in keyof T]: Input<T[K]>;
-};
-type ComponentArg = z.infer<typeof componentArgType>;
-type Secret = z.infer<typeof secretType>;
-type InputType = z.infer<typeof inputType>;
-type OutputRef = z.infer<typeof outputRefType>;
-
-interface ComponentParams<TArgs extends Record<string, unknown> = Record<string, unknown>, TSecrets extends Record<string, Secret> = Record<string, string>, TInputs extends Record<string, unknown> = Record<string, unknown>> {
-    name: string;
-    args: TArgs;
-    secrets: TSecrets;
-    inputs: Inputs<TInputs>;
-    context: EvaluationContext;
-}
-type InputComponentParams<TArgs extends Record<string, ComponentArg>, TInputs extends Record<string, unknown>> = {
-    name: string;
-} & OptionalEmptyFields<{
-    args: TArgs;
-    inputs: Inputs<TInputs>;
-}>;
-declare const componentMetaType: z.ZodObject<{
-    displayName: z.ZodString;
-    description: z.ZodString;
-    primaryIcon: z.ZodOptional<z.ZodString>;
-    primaryIconColor: z.ZodOptional<z.ZodString>;
-    secondaryIcon: z.ZodOptional<z.ZodString>;
-    secondaryIconColor: z.ZodOptional<z.ZodString>;
-    category: z.ZodOptional<z.ZodString>;
-    color: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    displayName: string;
-    description: string;
-    primaryIcon?: string | undefined;
-    primaryIconColor?: string | undefined;
-    secondaryIcon?: string | undefined;
-    secondaryIconColor?: string | undefined;
-    category?: string | undefined;
-    color?: string | undefined;
-}, {
-    displayName: string;
-    description: string;
-    primaryIcon?: string | undefined;
-    primaryIconColor?: string | undefined;
-    secondaryIcon?: string | undefined;
-    secondaryIconColor?: string | undefined;
-    category?: string | undefined;
-    color?: string | undefined;
-}>;
-type ComponentMeta = z.infer<typeof componentMetaType>;
-type ComponentOptions<TArgs extends Record<string, ComponentArg>, TSecrets extends Record<string, Secret>, TInputs extends Record<string, unknown>, TOutputs extends Record<string, unknown>> = {
-    type: string;
-    meta: ComponentMeta;
-    args?: ZodType<TArgs>;
-    inputs?: ZodType<TInputs>;
-    secrets?: ZodType<TSecrets>;
-    outputs: ZodType<TOutputs>;
-    create: (params: ComponentParams<TArgs, TSecrets, TInputs>) => Inputs<NoInfer<TOutputs>>;
-};
-type UnitOptions<TArgs extends Record<string, ComponentArg>, TSecrets extends Record<string, Secret>, TInputs extends Record<string, InputType>, TOutputs extends Record<string, InputType>> = Omit<ComponentOptions<TArgs, TSecrets, TInputs, TOutputs>, "create">;
-type Component<TArgs extends Record<string, ComponentArg> = {}, TSecrets extends Record<string, unknown> = {}, TInputs extends Record<string, InputType> = {}, TOutputs extends Record<string, InputType> = {}> = {
-    type: string;
-    meta: ComponentMeta;
-    args: ZodObject<{
-        [K in keyof TArgs]: ZodType<unknown>;
-    }>;
-    inputs: ZodObject<{
-        [K in keyof TInputs]: ZodType<unknown>;
-    }>;
-    secrets: ZodObject<{
-        [K in keyof TSecrets]: ZodType<Secret>;
-    }>;
-    outputs: ZodObject<{
-        [K in keyof TOutputs]: ZodType<unknown>;
-    }>;
-    (context: InputComponentParams<TArgs, TInputs>): Inputs<TOutputs>;
-};
-declare function isComponent(arg: unknown): arg is Component;
-declare function defineComponent<TArgs extends Record<string, ComponentArg> = {}, TSecrets extends Record<string, Secret> = {}, TInputs extends Record<string, InputType> = {}, TOutputs extends Record<string, InputType> = {}>(options: ComponentOptions<TArgs, TSecrets, TInputs, TOutputs>): Component<TArgs, TSecrets, TInputs, TOutputs>;
-declare function defineUnit<TArgs extends Record<string, ComponentArg>, TSecrets extends Record<string, Secret>, TInputs extends Record<string, InputType>, TOutputs extends Record<string, InputType>>(options: UnitOptions<TArgs, TSecrets, TInputs, TOutputs>): Component<TArgs, TSecrets, TInputs, TOutputs>;
-
-export { type Component, type ComponentMeta, type ComponentOptions, type ComponentParams, type EvaluationContext, type InputComponentParams, type StackDependency, type StackRegistration, type UnitOptions, componentMetaType, defineComponent, defineUnit, getCurrentEvaluationContext, isComponent, runEvaluation };

package/dist/index.mjs

@@ -1,114 +0,0 @@
-import { z } from 'zod';
-
-let evaluationContext;
-function runEvaluation(context, fn) {
-  evaluationContext = context;
-  try {
-    return fn();
-  } finally {
-    evaluationContext = void 0;
-  }
-}
-function getCurrentEvaluationContext() {
-  if (!evaluationContext) {
-    throw new Error("This method must be called while evaluating a configuration.");
-  }
-  return evaluationContext;
-}
-
-z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.array(z.string()),
-  z.undefined()
-]);
-z.union([z.string(), z.undefined()]);
-z.object({ type: z.string() });
-const outputRefType = z.object({
-  $output: z.string(),
-  project: z.string(),
-  stack: z.string()
-});
-function isOutputRef(value) {
-  return outputRefType.safeParse(value).success;
-}
-
-const componentMetaType = z.object({
-  displayName: z.string(),
-  description: z.string(),
-  primaryIcon: z.string().optional(),
-  primaryIconColor: z.string().optional(),
-  secondaryIcon: z.string().optional(),
-  secondaryIconColor: z.string().optional(),
-  category: z.string().optional(),
-  color: z.string().optional()
-});
-function isComponent(arg) {
-  return typeof arg === "function" && "type" in arg && "meta" in arg;
-}
-function defineComponent(options) {
-  function create(params) {
-    const { name, args, inputs } = params;
-    const context = getCurrentEvaluationContext();
-    const secrets = retreiveSecrets(options.secrets, context);
-    return options.create({
-      name,
-      args: args ?? {},
-      secrets,
-      inputs: inputs ?? {},
-      context
-    });
-  }
-  create.type = options.type;
-  create.meta = options.meta ?? {};
-  create.args = options.args ?? z.object({});
-  create.inputs = options.inputs ?? z.object({});
-  create.secrets = options.secrets ?? z.object({});
-  create.outputs = options.outputs ?? z.object({});
-  return create;
-}
-function defineUnit(options) {
-  return defineComponent({
-    ...options,
-    create({ name, args, secrets, inputs, context }) {
-      context.registerStack({
-        project: options.type,
-        stack: name,
-        config: args,
-        secrets: Object.keys(secrets),
-        dependencies: Object.values(inputs).flatMap((value) => {
-          if (isOutputRef(value)) {
-            return [{ project: value.project, stack: value.stack }];
-          }
-          return [];
-        })
-      });
-      return fillUnitOutputs(name, options.type, options.outputs);
-    }
-  });
-}
-function retreiveSecrets(secrets, context) {
-  if (!secrets) {
-    return {};
-  }
-  const secretValues = {};
-  const secretType = secrets;
-  for (const key of Object.keys(secretType.shape)) {
-    const secret = context.getSecret(key);
-    if (secret) {
-      secretValues[key] = secret;
-    }
-  }
-  return secrets.parse(secretValues);
-}
-function fillUnitOutputs(name, type, optionsOutputs) {
-  const outputs = {};
-  const outputType = optionsOutputs;
-  for (const key of Object.keys(outputType.shape)) {
-    outputs[key] = { $output: key, project: type, stack: name };
-  }
-  return outputs;
-}
-
-export { componentMetaType, defineComponent, defineUnit, getCurrentEvaluationContext, isComponent, runEvaluation };