@highstate/pulumi 0.19.1 → 0.21.1

package/dist/index.js

@@ -1,40 +1,16 @@
-import { output, secret, Config, StackReference } from '@pulumi/pulumi';
-export * from '@pulumi/pulumi';
-import { pathToFileURL } from 'node:url';
-import { HighstateConfigKey, unitConfigSchema, z, parseArgumentValue, runtimeSchema, parseInstanceId, compact, camelCaseToHumanReadable, unitArtifactSchema, decompact } from '@highstate/contract';
-import { mapValues } from 'remeda';
-
+// @bun
 // src/index.ts
-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
-    }
-  });
-}
+export * from "@pulumi/pulumi";
+
+// src/entity.ts
+import {
+  getEntityId,
+  HighstateSignature
+} from "@highstate/contract";
+import { output as output2 } from "@pulumi/pulumi";
+
+// src/utils.ts
+import { output } from "@pulumi/pulumi";
 function toPromise(input) {
   return new Promise((resolve) => output(input).apply(resolve));
 }
@@ -57,9 +33,128 @@ function apply(fn) {
   return (input) => output(input).apply(fn);
 }
 
+// src/entity.ts
+function makeEntity({
+  entity,
+  identity,
+  meta,
+  value
+}) {
+  const built = {
+    ...value,
+    $meta: {
+      type: entity.type,
+      identity,
+      ...meta
+    }
+  };
+  return entity.schema.parse(built);
+}
+function makeSecret(value) {
+  return {
+    [HighstateSignature.Secret]: true,
+    value
+  };
+}
+function makeSecretOutput(value) {
+  return output2(value).apply(makeSecret);
+}
+function makeSecretAsync(value) {
+  return toPromise(makeSecretOutput(value));
+}
+function makeEntityOutput({
+  entity,
+  identity,
+  meta,
+  value
+}) {
+  return output2({
+    ...value,
+    $meta: {
+      type: entity.type,
+      identity,
+      ...meta
+    }
+  }).apply((built) => entity.schema.parse(built));
+}
+function makeEntityAsync(options) {
+  return toPromise(makeEntityOutput(options));
+}
+function getCombinedIdentity(entities) {
+  const sortedIds = entities.map((source) => typeof source === "string" ? source : getEntityId(source)).sort();
+  return sortedIds.join(":");
+}
+function getCombinedIdentityOutput(entities) {
+  return output2(entities).apply(getCombinedIdentity);
+}
+function getCombinedIdentityAsync(entities) {
+  return toPromise(getCombinedIdentityOutput(entities));
+}
+// src/file.ts
+import { crc32 } from "zlib";
+import { output as output3 } from "@pulumi/pulumi";
+function makeFile({
+  name,
+  content,
+  contentType,
+  identity,
+  isSecret,
+  mode
+}) {
+  const stringContent = typeof content === "string" ? content : content.toString("base64");
+  const isBinary = typeof content !== "string";
+  const inferredContentType = contentType ?? (typeof content === "string" ? "text/plain" : "application/octet-stream");
+  const size = typeof content === "string" ? Buffer.byteLength(content, "utf-8") : content.byteLength;
+  return {
+    $meta: {
+      type: "common.file.v1",
+      identity: identity ?? crc32(stringContent).toString(16)
+    },
+    meta: {
+      name,
+      contentType: inferredContentType,
+      size,
+      mode
+    },
+    content: isSecret ? { type: "embedded-secret", value: makeSecret(stringContent), isBinary } : { type: "embedded", value: stringContent, isBinary }
+  };
+}
+function makeFileOutput(options) {
+  return output3(options).apply((opts) => makeFile(opts));
+}
+function makeFileAsync(options) {
+  return toPromise(makeFileOutput(options));
+}
+// src/resource-hooks.ts
+var hasResourceHooks = false;
+function setResourceHooks() {
+  hasResourceHooks = true;
+}
+function getHasResourceHooks() {
+  return hasResourceHooks;
+}
 // src/unit.ts
-var stackRefMap = /* @__PURE__ */ new Map();
+import { join } from "path";
+import { pathToFileURL } from "url";
+import {
+  camelCaseToHumanReadable,
+  HighstateConfigKey,
+  HighstateSignature as HighstateSignature2,
+  parseArgumentValue,
+  parseInstanceId,
+  runtimeSchema,
+  unitArtifactSchema,
+  unitConfigSchema,
+  z
+} from "@highstate/contract";
+import {
+  Config,
+  output as output4,
+  secret as pulumiSecret
+} from "@pulumi/pulumi";
+import { isPlainObject, mapValues } from "remeda";
 var instanceId;
+var stateId;
 var instanceName;
 var importBaseUrl;
 function getUnitInstanceId() {
@@ -68,6 +163,12 @@ function getUnitInstanceId() {
   }
   return instanceId;
 }
+function getUnitStateId() {
+  if (!stateId) {
+    throw new Error(`State id is not set. Did you call "forUnit" function?`);
+  }
+  return stateId;
+}
 function getUnitInstanceName() {
   if (!instanceName) {
     throw new Error(`Instance name is not set. Did you call "forUnit" function?`);
@@ -81,65 +182,34 @@ function getImportBaseUrl() {
   return importBaseUrl;
 }
 function getResourceComment() {
-  return `Managed by Highstate (${getUnitInstanceId()})`;
+  return `Managed by Highstate [${getUnitStateId()}]`;
 }
-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.`);
-  }
-  const key = `organization/${instanceType}/${stateId}`;
-  let stackRef = stackRefMap.get(key);
-  if (!stackRef) {
-    stackRef = new StackReference(key);
-    stackRefMap.set(key, stackRef);
-  }
-  return stackRef;
-}
-function getOutput(config, unit, inputName, input, refs) {
+function getInputValue(unit, inputName, input, entries) {
   const entity = unit.entities.get(input.type);
   if (!entity) {
     throw new Error(`Entity "${input.type}" not found in the unit "${unit.model.type}".`);
   }
-  const _getOutput = (ref) => {
-    const value = getStackRef(config, ref).requireOutput(ref.output);
-    return value.apply((value2) => {
-      if (ref.inclusion) {
-        if (value2 === null || value2 === void 0 || typeof value2 !== "object") {
-          throw new Error(
-            `Cannot extract field "${ref.inclusion.field}" from non-object output "${ref.output}" of instance "${ref.instanceId}".`
-          );
-        }
-        value2 = value2[ref.inclusion.field];
-      }
-      const schema = Array.isArray(value2) ? entity.schema.array() : entity.schema;
-      const result = schema.safeParse(value2);
-      if (!result.success) {
-        throw new Error(
-          `Invalid output "${ref.output}" from "${ref.instanceId}" for input "${inputName}": ${result.error.message}`
-        );
-      }
-      if (Array.isArray(value2)) {
-        return value2;
-      }
-      return input.multiple ? [value2] : value2;
-    });
-  };
-  const _getDecompactedOutput = (ref) => {
-    return _getOutput(ref).apply(decompact);
-  };
-  const values = output(refs.map(_getDecompactedOutput)).apply((values2) => values2.flat());
+  const values = entries.flatMap((entry) => {
+    const value = parseArgumentValue(entry.value);
+    const schema = Array.isArray(value) ? entity.schema.array() : entity.schema;
+    const result = schema.safeParse(value);
+    if (!result.success) {
+      throw new Error(`Invalid value for input "${inputName}": ${z.prettifyError(result.error)}`);
+    }
+    if (Array.isArray(result.data)) {
+      return result.data;
+    }
+    return input.multiple ? [result.data] : [result.data];
+  });
   if (!input.multiple) {
-    return values.apply((values2) => values2[0]);
+    return values[0];
   }
   return values;
 }
 function forUnit(unit) {
-  const config = new Config();
+  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) => {
     const value = parseArgumentValue(hsConfig.args[argName]);
     const result = arg[runtimeSchema].safeParse(value);
@@ -148,99 +218,93 @@ function forUnit(unit) {
     }
     return result.data;
   });
-  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;
+  const secrets = mapValues(unit.model.secrets, (secret, secretName) => {
+    const hasValue = secretName in hsConfig.secretValues;
+    if (!hasValue && !secret.required) {
+      return secret.schema.default ? pulumiSecret(secret.schema.default) : undefined;
     }
-    if (!hasValue && secret2.required) {
+    if (!hasValue && secret.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 rawValue = hsConfig.secretValues[secretName];
+    const value = parseArgumentValue(rawValue);
+    const result = secret[runtimeSchema].safeParse(value);
+    if (!result.success) {
+      throw new Error(`Invalid secret "${secretName}": ${z.prettifyError(result.error)}`);
+    }
+    return pulumiSecret(result.data);
   });
   const inputs = mapValues(unit.model.inputs, (input, inputName) => {
     const value = hsConfig.inputs[inputName];
     if (!value) {
       if (input.multiple) {
-        return output([]);
+        return [];
       }
-      return void 0;
+      return;
     }
-    return getOutput(hsConfig, unit, inputName, input, value);
+    return getInputValue(unit, inputName, input, value);
   });
   const [type, name] = parseInstanceId(hsConfig.instanceId);
   instanceId = hsConfig.instanceId;
+  stateId = hsConfig.stateId;
   instanceName = name;
   importBaseUrl = pathToFileURL(hsConfig.importBasePath);
   return {
     instanceId: hsConfig.instanceId,
+    stateId: hsConfig.stateId,
     type,
     name,
     args,
     secrets,
     inputs,
     invokedTriggers: hsConfig.invokedTriggers,
-    getSecret: ((name2, factory) => {
+    getSecret: (name2, factory) => {
       if (!factory) {
         return secrets[name2];
       }
-      const value = secrets[name2] ?? secret(factory());
+      const value = secrets[name2] ?? pulumiSecret(factory());
       secrets[name2] = value;
       return value;
-    }),
+    },
+    setSecret: (name2, value) => {
+      secrets[name2] = pulumiSecret(value);
+    },
     outputs: async (outputs = {}) => {
-      const result = mapValues(outputs, (outputValue, outputName) => {
+      const resolvedOutputs = await toPromise(outputs);
+      const result = mapValues(resolvedOutputs, (outputValue, outputName) => {
         if (outputName === "$statusFields") {
-          return output(outputValue).apply(mapStatusFields);
+          return mapStatusFields(outputValue);
         }
         if (outputName === "$pages") {
-          return output(outputValue).apply(mapPages);
+          return mapPages(outputValue);
         }
         if (outputName === "$terminals") {
-          return output(outputValue).apply(mapTerminals);
+          return mapTerminals(outputValue);
         }
         if (outputName === "$triggers") {
-          return output(outputValue).apply(mapTriggers);
+          return mapTriggers(outputValue);
         }
         if (outputName === "$workers") {
-          return output(outputValue).apply(mapWorkers);
+          return mapWorkers(outputValue);
         }
         if (outputName.startsWith("$")) {
           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}", but was passed to outputs(...).`
-          );
+          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}". It looks like a bug in the unit definition.`
-          );
+          throw new Error(`Entity "${outputModel.type}" not found in the unit "${unit.model.type}". It looks like a bug in the unit definition.`);
+        }
+        const schema = outputModel.multiple ? entity.schema.array() : entity.schema;
+        const result2 = schema.safeParse(outputValue);
+        if (!result2.success) {
+          throw new Error(`Invalid value for output "${outputName}" of type "${outputModel.type}": ${z.prettifyError(result2.error)}`);
         }
-        return output(outputValue).apply((value) => {
-          const schema = outputModel.multiple ? entity.schema.array() : entity.schema;
-          const result2 = schema.safeParse(value);
-          if (!result2.success) {
-            throw new Error(
-              `Invalid value for output "${outputName}" of type "${outputModel.type}": ${z.prettifyError(
-                result2.error
-              )}`
-            );
-          }
-          return compact(result2.data);
-        });
+        return result2.data;
       });
-      await Promise.all(Object.values(result).map((o) => toPromise(o)));
       result.$secrets = secrets;
       const artifactsMap = {};
       for (const [outputName, outputValue] of Object.entries(outputs)) {
@@ -253,16 +317,55 @@ function forUnit(unit) {
       if (Object.keys(artifactsMap).length > 0) {
         result.$artifacts = artifactsMap;
       }
-      return result;
+      result.$hasResourceHooks = getHasResourceHooks();
+      return wrapHighstateSecretValues(result);
     }
   };
 }
+function wrapHighstateSecretValues(data) {
+  const cache = new WeakMap;
+  const traverse = (value) => {
+    if (value === null || value === undefined || typeof value !== "object") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      const cached2 = cache.get(value);
+      if (cached2) {
+        return cached2;
+      }
+      const mapped2 = [];
+      cache.set(value, mapped2);
+      for (const item of value) {
+        mapped2.push(traverse(item));
+      }
+      return mapped2;
+    }
+    if (!isPlainObject(value)) {
+      return value;
+    }
+    const cached = cache.get(value);
+    if (cached) {
+      return cached;
+    }
+    const record = value;
+    const mapped = {};
+    cache.set(value, mapped);
+    for (const [key, nestedValue] of Object.entries(record)) {
+      mapped[key] = traverse(nestedValue);
+    }
+    if (record[HighstateSignature2.Secret] === true && "value" in record) {
+      return pulumiSecret(mapped);
+    }
+    return mapped;
+  };
+  return traverse(data);
+}
 function mapStatusFields(status) {
   if (!status) {
     return [];
   }
   if (Array.isArray(status)) {
-    return status.filter((field) => field?.value !== void 0).map((field) => {
+    return status.filter((field) => field?.value !== undefined).map((field) => {
       return {
         name: field.name,
         meta: {
@@ -274,7 +377,7 @@ function mapStatusFields(status) {
   }
   return Object.entries(status).map(([name, field]) => {
     if (!field) {
-      return void 0;
+      return;
     }
     if (typeof field === "string" || typeof field === "number" || typeof field === "boolean" || Array.isArray(field)) {
       return {
@@ -293,68 +396,68 @@ function mapStatusFields(status) {
       },
       name
     };
-  }).filter((field) => field?.value !== void 0);
+  }).filter((field) => field?.value !== undefined);
 }
 function mapPages(pages) {
   if (!pages) {
-    return output([]);
+    return output4([]);
   }
   if (!Array.isArray(pages)) {
     pages = Object.entries(pages).map(([name, page]) => {
       if (!page) {
-        return void 0;
+        return;
       }
       return { ...page, name };
     });
   }
-  return output(pages.filter((page) => !!page));
+  return output4(pages.filter((page) => !!page));
 }
 function mapTerminals(terminals) {
   if (!terminals) {
-    return output([]);
+    return output4([]);
   }
   if (!Array.isArray(terminals)) {
     terminals = Object.entries(terminals).map(([name, terminal]) => {
       if (!terminal) {
-        return void 0;
+        return;
       }
       return { ...terminal, name };
     });
   }
-  return output(terminals.filter((terminal) => !!terminal));
+  return output4(terminals.filter((terminal) => !!terminal));
 }
 function mapTriggers(triggers) {
   if (!triggers) {
-    return output([]);
+    return output4([]);
   }
   if (!Array.isArray(triggers)) {
     triggers = Object.entries(triggers).map(([name, trigger]) => {
       if (!trigger) {
-        return void 0;
+        return;
       }
       return { ...trigger, name };
     });
   }
-  return output(triggers.filter((trigger) => !!trigger));
+  return output4(triggers.filter((trigger) => !!trigger));
 }
 function mapWorkers(workers) {
   if (!workers) {
-    return output([]);
+    return output4([]);
   }
   if (!Array.isArray(workers)) {
     workers = Object.entries(workers).map(([name, worker]) => {
       if (!worker) {
-        return void 0;
+        return;
       }
       return { ...worker, name };
     });
   }
-  return output(workers.filter((worker) => !!worker));
+  return output4(workers.filter((worker) => !!worker));
 }
 function extractObjectsFromValue(schema, data) {
   const result = [];
   function traverse(obj) {
-    if (obj === null || obj === void 0 || typeof obj !== "object") {
+    if (obj === null || obj === undefined || typeof obj !== "object") {
       return;
     }
     if (Array.isArray(obj)) {
@@ -375,7 +478,34 @@ function extractObjectsFromValue(schema, data) {
   traverse(data);
   return result;
 }
-
-export { apply, fileFromBuffer, fileFromString, forUnit, getImportBaseUrl, getResourceComment, getUnitInstanceId, getUnitInstanceName, normalize, normalizeInputs, normalizeInputsAndMap, toPromise };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+function getUnitTempPath() {
+  return join("/tmp/highstate", getUnitStateId());
+}
+export {
+  toPromise,
+  setResourceHooks,
+  normalizeInputsAndMap,
+  normalizeInputs,
+  normalize,
+  makeSecretOutput,
+  makeSecretAsync,
+  makeSecret,
+  makeFileOutput,
+  makeFileAsync,
+  makeFile,
+  makeEntityOutput,
+  makeEntityAsync,
+  makeEntity,
+  getUnitTempPath,
+  getUnitStateId,
+  getUnitInstanceName,
+  getUnitInstanceId,
+  getResourceComment,
+  getImportBaseUrl,
+  getHasResourceHooks,
+  getCombinedIdentityOutput,
+  getCombinedIdentityAsync,
+  getCombinedIdentity,
+  forUnit,
+  apply
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/pulumi",
-  "version": "0.19.1",
+  "version": "0.21.1",
   "type": "module",
   "files": [
     "dist",
@@ -28,25 +28,25 @@
       "platform"
     ]
   },
+  "scripts": {
+    "build": "highstate build",
+    "typecheck": "tsgo --noEmit --skipLibCheck",
+    "biome": "biome check --write --unsafe --error-on-warnings",
+    "biome:check": "biome check --error-on-warnings"
+  },
   "dependencies": {
-    "@pulumi/pulumi": "3.198.0",
+    "@highstate/contract": "0.20.0",
+    "@pulumi/pulumi": "3.232.0",
     "deepmerge-ts": "^7.1.5",
     "remeda": "^2.21.0",
-    "type-fest": "^4.41.0",
-    "@highstate/contract": "0.19.1"
+    "type-fest": "^4.41.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.0",
-    "@typescript/native-preview": "^7.0.0-dev.20250920.1",
-    "@highstate/cli": "0.19.1"
+    "@highstate/cli": "0.20.0",
+    "@typescript/native-preview": "^7.0.0-dev.20250920.1"
   },
   "repository": {
     "url": "https://github.com/highstate-io/highstate"
-  },
-  "scripts": {
-    "build": "highstate build",
-    "typecheck": "tsgo --noEmit --skipLibCheck",
-    "biome": "biome check --write --unsafe --error-on-warnings",
-    "biome:check": "biome check --error-on-warnings"
   }
-}
+}