@highstate/pulumi 0.9.16 → 0.9.19

package/dist/highstate.manifest.json

@@ -1,5 +1,5 @@
 {
   "sourceHashes": {
-    "./dist/index.js": 2152865667
+    "./dist/index.js": 2212294583
   }
 }

package/dist/index.js

@@ -1,69 +1,115 @@
-import { getStack, secret, Config, output, all, StackReference } from '@pulumi/pulumi';
+import { output, secret, Config, StackReference } from '@pulumi/pulumi';
 export * from '@pulumi/pulumi';
-import { getInstanceId, camelCaseToHumanReadable, HighstateSignature, parseInstanceId } from '@highstate/contract';
-import { Type } from '@sinclair/typebox';
-import { mapValues, pipe, pickBy } from 'remeda';
-import { Ajv } from 'ajv';
+import { HighstateConfigKey, unitConfigSchema, z, parseArgumentValue, runtimeSchema, parseInstanceId, camelCaseToHumanReadable, unitArtifactSchema } from '@highstate/contract';
+import { mapValues } from 'remeda';
 
 // src/index.ts
-var createdSecrets = {};
-function getOrCreateSecret(secrets, key, create) {
-  return secrets[key].apply((value) => {
-    if (value !== void 0) {
-      createdSecrets[key] = value;
-      return value;
+function fileFromString(name, content, { contentType = "text/plain", isSecret = false, mode } = {}) {
+  return output({
+    meta: {
+      name,
+      contentType,
+      size: output(content).apply((content2) => Buffer.byteLength(content2, "utf8")),
+      mode
+    },
+    content: {
+      type: "embedded",
+      value: isSecret ? secret(content) : content
+    }
+  });
+}
+function fileFromBuffer(name, content, { contentType = "application/octet-stream", isSecret = false, mode } = {}) {
+  const base64Content = content.toString("base64");
+  return output({
+    meta: {
+      name,
+      contentType,
+      size: output(content).apply((content2) => content2.byteLength),
+      mode
+    },
+    content: {
+      type: "embedded",
+      isBinary: true,
+      value: isSecret ? secret(base64Content) : base64Content
     }
-    const secretValue = createdSecrets[key] ?? secret(create());
-    createdSecrets[key] = secretValue;
-    return secretValue;
   });
 }
-function storeSecret(_secrets, key, value) {
-  createdSecrets[key] = value;
+function toPromise(input) {
+  return new Promise((resolve) => output(input).apply(resolve));
+}
+function normalize(item, collection) {
+  if (item && collection) {
+    return [item, ...collection];
+  }
+  if (item) {
+    return [item];
+  }
+  return collection ?? [];
+}
+function normalizeInputs(item, collection) {
+  return output({ item, collection }).apply(({ item: item2, collection: collection2 }) => normalize(item2, collection2));
+}
+function normalizeInputsAndMap(item, collection, mapFn) {
+  return normalizeInputs(item, collection).apply((values) => values.map(mapFn));
+}
+function apply(fn) {
+  return (input) => output(input).apply(fn);
 }
 
 // src/unit.ts
-var ajv = new Ajv({ strict: false });
 var stackRefMap = /* @__PURE__ */ new Map();
-var [projectId, instanceName] = getStack().split("_");
 var instanceId;
+var instanceName;
 function getUnitInstanceId() {
   if (!instanceId) {
-    throw new Error("Instance id is not set. Did you call 'forUnit' function?");
+    throw new Error(`Instance id is not set. Did you call "forUnit" function?`);
   }
   return instanceId;
 }
-function getResourceComment() {
-  return `Managed by Highstate Unit (${getUnitInstanceId()})`;
-}
 function getUnitInstanceName() {
+  if (!instanceName) {
+    throw new Error(`Instance name is not set. Did you call "forUnit" function?`);
+  }
   return instanceName;
 }
-function getStackRef(input) {
-  const [instanceType, instanceName2] = parseInstanceId(input.instanceId);
-  const key = `organization/${instanceType}/${projectId}_${instanceName2}`;
-  if (!stackRefMap.has(key)) {
-    stackRefMap.set(key, new StackReference(key));
+function getResourceComment() {
+  return `Managed by Highstate (${getUnitInstanceId()})`;
+}
+function getStackRef(config, input) {
+  const [instanceType] = parseInstanceId(input.instanceId);
+  const stateId = config.stateIdMap[input.instanceId];
+  if (!stateId) {
+    throw new Error(`State ID for instance "${input.instanceId}" not found in the unit config.`);
   }
-  return stackRefMap.get(key);
+  const key = `organization/${instanceType}/${stateId}`;
+  let stackRef = stackRefMap.get(key);
+  if (!stackRef) {
+    stackRef = new StackReference(key);
+    stackRefMap.set(key, stackRef);
+  }
+  return stackRef;
 }
-function getOutput(unit, input, refs) {
+function getOutput(config, unit, input, refs) {
   const entity = unit.entities.get(input.type);
   if (!entity) {
-    throw new Error(`Entity '${input.type}' not found in the unit '${unit.model.type}'.`);
+    throw new Error(`Entity "${input.type}" not found in the unit "${unit.model.type}".`);
   }
   const _getOutput = (ref) => {
-    const value = getStackRef(ref).requireOutput(ref.output);
+    const value = getStackRef(config, ref).requireOutput(ref.output);
     return value.apply((value2) => {
       if (Array.isArray(value2)) {
         for (const [index, item] of value2.entries()) {
-          if (!ajv.validate(entity.schema, item)) {
-            throw new Error(`Invalid output for '${input.type}[${index}]': ${ajv.errorsText()}`);
+          const result = entity.schema.safeParse(item);
+          if (!result.success) {
+            throw new Error(
+              `Invalid output for "${input.type}[${index}]": ${z.prettifyError(result.error)}`
+            );
           }
         }
       } else {
-        if (!ajv.validate(entity.schema, value2)) {
-          throw new Error(`Invalid output for '${input.type}': ${ajv.errorsText()}`);
+        const result = entity.schema.safeParse(value2);
+        if (!result.success) {
+          throw new Error(`Invalid output for "${input.type}": ${z.prettifyError(result.error)}`);
         }
       }
       if (Array.isArray(value2)) {
@@ -78,129 +124,65 @@ function getOutput(unit, input, refs) {
   }
   return values;
 }
-function isAnyOfSchema(schema, itemType) {
-  if (schema.anyOf) {
-    return Object.values(schema.anyOf).every(
-      (schema2) => isAnyOfSchema(schema2, itemType)
-    );
-  }
-  return schema.type === itemType;
-}
-function isStringSchema(schema) {
-  if (schema.type === "string") {
-    return true;
-  }
-  if (isAnyOfSchema(schema, "string")) {
-    return true;
-  }
-  return false;
-}
-function isNumberSchema(schema) {
-  if (schema.type === "number") {
-    return true;
-  }
-  if (isAnyOfSchema(schema, "number")) {
-    return true;
-  }
-  return false;
-}
-function isBooleanSchema(schema) {
-  if (schema.type === "boolean") {
-    return true;
-  }
-  if (isAnyOfSchema(schema, "boolean")) {
-    return true;
-  }
-  return false;
-}
 function forUnit(unit) {
   const config = new Config();
+  const rawHSConfig = config.requireObject(HighstateConfigKey.Config);
+  const hsConfig = unitConfigSchema.parse(rawHSConfig);
+  const rawHsSecrets = config.requireSecretObject(HighstateConfigKey.Secrets).apply((secrets2) => z.record(z.string(), z.unknown()).parse(secrets2));
   const args = mapValues(unit.model.args, (arg, argName) => {
-    switch (true) {
-      case isStringSchema(arg.schema): {
-        if (arg.required) {
-          return config.require(argName);
-        }
-        return config.get(argName) || arg.schema.default;
-      }
-      case isNumberSchema(arg.schema): {
-        if (arg.required) {
-          return config.requireNumber(argName);
-        }
-        const value = config.get(argName);
-        if (!value) {
-          return arg.schema.default;
-        }
-        return config.getNumber(argName) ?? arg.schema.default;
-      }
-      case isBooleanSchema(arg.schema): {
-        if (arg.required) {
-          return config.requireBoolean(argName);
-        }
-        const value = config.get(argName);
-        if (!value) {
-          return arg.schema.default;
-        }
-        return config.getBoolean(argName) ?? arg.schema.default;
-      }
-      default: {
-        if (!arg.required) {
-          const value2 = config.get(argName);
-          if (!value2) {
-            return arg.schema.default;
-          }
-        }
-        const value = arg.required ? config.requireObject(argName) : config.getObject(argName);
-        if (value === void 0) return arg.schema.default;
-        if (!ajv.validate(arg.schema, value)) {
-          throw new Error(`Invalid config for '${argName}': ${ajv.errorsText()}`);
-        }
-        return value;
-      }
+    const value = parseArgumentValue(hsConfig.args[argName]);
+    const result = arg[runtimeSchema].safeParse(value);
+    if (!result.success) {
+      throw new Error(`Invalid argument "${argName}": ${z.prettifyError(result.error)}`);
     }
+    return result.data;
   });
-  const secrets = output(
-    mapValues(unit.model.secrets, (secret3, secretName) => {
-      switch (true) {
-        case isStringSchema(secret3.schema): {
-          return secret3.required ? config.requireSecret(secretName) : config.getSecret(secretName);
-        }
-        case isNumberSchema(secret3.schema): {
-          return secret3.required ? config.requireSecretNumber(secretName) : config.getSecretNumber(secretName);
-        }
-        case isBooleanSchema(secret3.schema): {
-          return secret3.required ? config.requireSecretBoolean(secretName) : config.getSecretBoolean(secretName);
-        }
-        default: {
-          const value = secret3.required ? config.requireSecretObject(secretName) : config.getSecretObject(secretName);
-          if (!ajv.validate(secret3.schema, value)) {
-            throw new Error(`Invalid secret for '${secretName}': ${ajv.errorsText()}`);
-          }
-          return value;
-        }
+  const secrets = mapValues(unit.model.secrets, (secret2, secretName) => {
+    const hasValue = hsConfig.secretNames.includes(secretName);
+    if (!hasValue && !secret2.required) {
+      return secret2.schema.default ? secret(secret2.schema.default) : void 0;
+    }
+    if (!hasValue && secret2.required) {
+      throw new Error(`Secret "${secretName}" is required but not provided.`);
+    }
+    return rawHsSecrets[secretName].apply((rawValue) => {
+      const value = parseArgumentValue(rawValue);
+      const result = secret2[runtimeSchema].safeParse(value);
+      if (!result.success) {
+        throw new Error(`Invalid secret "${secretName}": ${z.prettifyError(result.error)}`);
       }
-    })
-  );
+      return secret(result.data);
+    });
+  });
   const inputs = mapValues(unit.model.inputs, (input, inputName) => {
-    const value = input.required ? config.requireObject(`input.${inputName}`) : config.getObject(`input.${inputName}`);
+    const value = hsConfig.inputs[inputName];
     if (!value) {
       if (input.multiple) {
-        return output([]);
+        return [];
       }
       return void 0;
     }
-    return getOutput(unit, input, value);
+    return getOutput(hsConfig, unit, input, value);
   });
-  const type = unit.model.type;
-  instanceId = getInstanceId(type, instanceName);
+  const [type, name] = parseInstanceId(hsConfig.instanceId);
+  instanceId = hsConfig.instanceId;
+  instanceName = name;
   return {
-    args,
-    instanceId,
+    instanceId: hsConfig.instanceId,
     type,
-    name: instanceName,
+    name,
+    args,
     secrets,
     inputs,
-    invokedTriggers: config.getObject("$invokedTriggers") ?? [],
+    invokedTriggers: hsConfig.invokedTriggers,
+    getSecret: (name2, factory) => {
+      if (!factory) {
+        return secrets[name2];
+      }
+      const value = secrets[name2] ?? secret(factory());
+      secrets[name2] = value;
+      return value;
+    },
     outputs: async (outputs = {}) => {
       const result = mapValues(outputs, (outputValue, outputName) => {
         if (outputName === "$statusFields") {
@@ -215,45 +197,43 @@ function forUnit(unit) {
         if (outputName === "$triggers") {
           return output(outputValue).apply(mapTriggers);
         }
+        if (outputName === "$workers") {
+          return output(outputValue).apply(mapWorkers);
+        }
         if (outputName.startsWith("$")) {
-          throw new Error(`Unknown extra output '${outputName}'.`);
+          throw new Error(`Unknown extra output "${outputName}".`);
         }
         const outputModel = unit.model.outputs[outputName];
         if (!outputModel) {
-          throw new Error(`Output '${outputName}' not found in the unit '${unit.model.type}'.`);
+          throw new Error(
+            `Output "${outputName}" not found in the unit "${unit.model.type}", but was passed to outputs(...).`
+          );
         }
         const entity = unit.entities.get(outputModel.type);
         if (!entity) {
           throw new Error(
-            `Entity '${outputModel.type}' not found in the unit '${unit.model.type}'.`
+            `Entity "${outputModel.type}" not found in the unit "${unit.model.type}". It looks like a bug in the unit definition.`
           );
         }
         return output(outputValue).apply((value) => {
-          if (value === void 0) {
-            if (outputModel.required) {
-              throw new Error(`Output '${outputName}' is required.`);
-            }
-            return void 0;
+          const schema = outputModel.multiple ? entity.schema.array() : entity.schema;
+          const result2 = schema.safeParse(value);
+          if (!result2.success) {
+            throw new Error(
+              `Invalid output "${outputName}" of type "${outputModel.type}": ${z.prettifyError(result2.error)}`
+            );
           }
-          const schema = outputModel.multiple ? Type.Array(entity.schema) : entity.schema;
-          if (!ajv.validate(schema, value)) {
-            throw new Error(`Invalid output for '${outputName}': ${ajv.errorsText()}`);
-          }
-          return value;
+          return result2.data;
         });
       });
-      await Promise.all(Object.values(result).map((o) => outputToPromise(o)));
-      if (Object.keys(createdSecrets).length > 0) {
-        result.$secrets = createdSecrets;
-      }
+      await Promise.all(Object.values(result).map((o) => toPromise(o)));
+      result.$secrets = secrets;
       const artifactsMap = {};
       for (const [outputName, outputValue] of Object.entries(outputs)) {
-        if (!outputName.startsWith("$")) {
-          const resolvedValue = await outputToPromise(outputValue);
-          const artifacts = extractArtifactsFromValue(resolvedValue);
-          if (artifacts.length > 0) {
-            artifactsMap[outputName] = artifacts;
-          }
+        const resolvedValue = await toPromise(outputValue);
+        const artifacts = extractObjectsFromValue(unitArtifactSchema, resolvedValue);
+        if (artifacts.length > 0) {
+          artifactsMap[outputName] = artifacts;
         }
       }
       if (Object.keys(artifactsMap).length > 0) {
@@ -263,15 +243,12 @@ function forUnit(unit) {
     }
   };
 }
-function outputToPromise(o) {
-  return new Promise((resolve) => output(o).apply(resolve));
-}
 function mapStatusFields(status) {
   if (!status) {
     return [];
   }
   if (Array.isArray(status)) {
-    return status.filter((field) => !!field?.value).map((field) => {
+    return status.filter((field) => field?.value !== void 0).map((field) => {
       return {
         name: field.name,
         meta: {
@@ -302,47 +279,25 @@ function mapStatusFields(status) {
       },
       name
     };
-  }).filter((field) => !!field?.value);
+  }).filter((field) => field?.value !== void 0);
 }
 function mapPages(pages) {
   if (!pages) {
-    return [];
+    return output([]);
   }
-  if (Array.isArray(pages)) {
-    return pages.filter((page) => !!page);
+  if (!Array.isArray(pages)) {
+    pages = Object.entries(pages).map(([name, page]) => {
+      if (!page) {
+        return void 0;
+      }
+      return { ...page, name };
+    });
   }
-  return Object.entries(pages).filter(([, page]) => !!page).map(([name, page]) => ({ ...page, name }));
-}
-function fileFromString(name, content, contentType = "text/plain", isSecret = false) {
-  return {
-    meta: {
-      name,
-      contentType,
-      size: Buffer.byteLength(content, "utf8")
-    },
-    content: {
-      type: "embedded",
-      value: isSecret ? secret(content) : content
-    }
-  };
-}
-function fileFromBuffer(name, content, contentType = "application/octet-stream", isSecret = false) {
-  return {
-    meta: {
-      name,
-      contentType,
-      size: content.byteLength,
-      isBinary: true
-    },
-    content: {
-      type: "embedded",
-      value: isSecret ? secret(content.toString("base64")) : content.toString("base64")
-    }
-  };
+  return output(pages.filter((page) => !!page));
 }
 function mapTerminals(terminals) {
   if (!terminals) {
-    return [];
+    return output([]);
   }
   if (!Array.isArray(terminals)) {
     terminals = Object.entries(terminals).map(([name, terminal]) => {
@@ -352,49 +307,38 @@ function mapTerminals(terminals) {
       return { ...terminal, name };
     });
   }
-  return terminals.filter((terminal) => !!terminal).map((terminal) => {
-    if (!terminal.spec.files) {
-      return terminal;
-    }
-    return {
-      ...terminal,
-      spec: {
-        ...terminal.spec,
-        files: pipe(
-          terminal.spec.files,
-          mapValues((file) => {
-            if (typeof file === "string") {
-              return {
-                meta: {
-                  name: "content",
-                  contentType: "text/plain",
-                  size: Buffer.byteLength(file, "utf8")
-                },
-                content: {
-                  type: "embedded",
-                  value: file
-                }
-              };
-            }
-            return file;
-          }),
-          pickBy((value) => !!value)
-        )
-      }
-    };
-  });
+  return output(terminals.filter((terminal) => !!terminal));
 }
 function mapTriggers(triggers) {
   if (!triggers) {
-    return [];
+    return output([]);
+  }
+  if (!Array.isArray(triggers)) {
+    triggers = Object.entries(triggers).map(([name, trigger]) => {
+      if (!trigger) {
+        return void 0;
+      }
+      return { ...trigger, name };
+    });
+  }
+  return output(triggers.filter((trigger) => !!trigger));
+}
+function mapWorkers(workers) {
+  if (!workers) {
+    return output([]);
   }
-  if (Array.isArray(triggers)) {
-    return triggers.filter((trigger) => !!trigger);
+  if (!Array.isArray(workers)) {
+    workers = Object.entries(workers).map(([name, worker]) => {
+      if (!worker) {
+        return void 0;
+      }
+      return { ...worker, name };
+    });
   }
-  return Object.entries(triggers).filter(([, trigger]) => !!trigger).map(([name, trigger]) => ({ ...trigger, name }));
+  return output(workers.filter((worker) => !!worker));
 }
-function extractArtifactsFromValue(data) {
-  const artifacts = [];
+function extractObjectsFromValue(schema, data) {
+  const result = [];
   function traverse(obj) {
     if (obj === null || obj === void 0 || typeof obj !== "object") {
       return;
@@ -405,91 +349,19 @@ function extractArtifactsFromValue(data) {
       }
       return;
     }
-    const record = obj;
-    if (HighstateSignature.Artifact in record) {
-      const artifactData = record[HighstateSignature.Artifact];
-      artifacts.push(artifactData);
-      record[HighstateSignature.Artifact] = { hash: artifactData.hash };
+    const parseResult = schema.safeParse(obj);
+    if (parseResult.success) {
+      result.push(parseResult.data);
       return;
     }
-    for (const value of Object.values(record)) {
+    for (const value of Object.values(obj)) {
       traverse(value);
     }
   }
   traverse(data);
-  return artifacts;
-}
-function flattenInputs(...values) {
-  return all(values).apply((allValues) => {
-    const result = [];
-    for (const value of allValues) {
-      if (Array.isArray(value)) {
-        result.push(...value);
-      } else if (value) {
-        result.push(value);
-      }
-    }
-    return result;
-  });
-}
-function mapInputs(array, fn) {
-  return output(array).apply((array2) => {
-    return array2?.map((v, index) => fn(v, index, array2)) ?? [];
-  });
-}
-function flatMapInput(...args) {
-  const fn = args.pop();
-  const values = args;
-  return mapInputs(flattenInputs(...values), fn);
-}
-function mapOptional(input, func) {
-  if (input === void 0) {
-    return void 0;
-  }
-  return func(input);
-}
-function toPromise(input) {
-  return new Promise((resolve) => output(input).apply(resolve));
-}
-function singleton(factory) {
-  let instance;
-  return () => {
-    if (instance === void 0) {
-      instance = factory();
-    }
-    return instance;
-  };
-}
-function providerFactory(factory) {
-  const instances = /* @__PURE__ */ new Map();
-  return (name) => {
-    if (!instances.has(name)) {
-      instances.set(name, factory(name));
-    }
-    return instances.get(name);
-  };
-}
-function mergeInputObjects(...objects) {
-  return output(objects).apply((array) => {
-    return Object.assign({}, ...array);
-  });
-}
-function normalize(item, collection) {
-  if (item && collection) {
-    return [item, ...collection];
-  }
-  if (item) {
-    return [item];
-  }
-  return collection ?? [];
-}
-function apply(fn) {
-  return (input) => output(input).apply(fn);
-}
-function applyMap(fn) {
-  return (input) => output(input).apply((array) => array.map(fn));
+  return result;
 }
 
-export { apply, applyMap, fileFromBuffer, fileFromString, flatMapInput, flattenInputs, forUnit, getOrCreateSecret, getResourceComment, getUnitInstanceId, getUnitInstanceName, mapInputs, mapOptional, mergeInputObjects, normalize, providerFactory, singleton, storeSecret, toPromise };
+export { apply, fileFromBuffer, fileFromString, forUnit, getResourceComment, getUnitInstanceId, getUnitInstanceName, normalize, normalizeInputs, normalizeInputsAndMap, toPromise };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map