@effect-opcua/codegen 0.1.0-alpha.0

package/dist/config.mjs

@@ -0,0 +1,158 @@
+import { codegenError, invalidConfig } from "./errors.mjs";
+import { Effect } from "effect";
+import { resolve } from "node:path";
+import { unrun } from "unrun";
+
+//#region src/config.ts
+const defineConfig = (config) => config;
+const loadConfig = (path = "effect-opcua.codegen.ts") => Effect.gen(function* () {
+	const resolved = resolve(path);
+	const module = (yield* Effect.tryPromise({
+		try: () => unrun({ path: resolved }),
+		catch: (cause) => codegenError({
+			_tag: "Config",
+			path: resolved
+		}, [{
+			severity: "error",
+			code: "config.loadFailed",
+			message: `Failed to load config at ${resolved}`,
+			file: resolved,
+			cause
+		}])
+	})).module;
+	const exportedConfig = isRecord(module) && "default" in module ? module.default : module;
+	if (exportedConfig === void 0) return yield* Effect.fail(codegenError({
+		_tag: "Config",
+		path: resolved
+	}, [{
+		severity: "error",
+		code: "config.loadFailed",
+		message: "Config module must have a default export",
+		file: resolved
+	}]));
+	return yield* normalizeConfig(exportedConfig);
+});
+const normalizeConfig = (config) => Effect.gen(function* () {
+	if (!isRecord(config)) return yield* Effect.fail(invalidConfig("Config must be an object"));
+	const unsupported = unsupportedKeys(config, [
+		"endpointUrl",
+		"clientOptions",
+		"userIdentity",
+		"outputDir",
+		"roots",
+		"exclude",
+		"discovery",
+		"diagnostics"
+	]);
+	if (unsupported.length > 0) return yield* Effect.fail(invalidConfig(`Unsupported config keys: ${unsupported.join(", ")}`));
+	const endpointUrl = config.endpointUrl;
+	if (typeof endpointUrl !== "string" || endpointUrl.trim() === "") return yield* Effect.fail(invalidConfig("Missing endpointUrl"));
+	const outputDir = config.outputDir;
+	if (typeof outputDir !== "string" || outputDir.trim() === "") return yield* Effect.fail(invalidConfig("Missing outputDir"));
+	if (!Array.isArray(config.roots) || config.roots.length === 0) return yield* Effect.fail(invalidConfig("Config roots must not be empty"));
+	const roots = yield* Effect.forEach(config.roots, normalizeRoot);
+	const excludeInput = config.exclude ?? [];
+	if (!Array.isArray(excludeInput)) return yield* Effect.fail(invalidConfig("exclude must be an array"));
+	const exclude = yield* Effect.forEach(excludeInput, normalizeExcludeRule);
+	const diagnostics = normalizeDiagnostics(config.diagnostics);
+	if (diagnostics instanceof Error) return yield* Effect.fail(invalidConfig(diagnostics.message));
+	const discovery = normalizeDiscovery(config.discovery);
+	if (discovery instanceof Error) return yield* Effect.fail(invalidConfig(discovery.message));
+	return {
+		endpointUrl,
+		clientOptions: config.clientOptions,
+		userIdentity: config.userIdentity,
+		outputDir,
+		roots,
+		exclude,
+		discovery,
+		diagnostics
+	};
+});
+const normalizeRoot = (root) => Effect.gen(function* () {
+	if (!isRecord(root)) return yield* Effect.fail(invalidConfig("Each root must be an object"));
+	const unsupported = unsupportedKeys(root, [
+		"path",
+		"nodeId",
+		"exportPrefix"
+	]);
+	if (unsupported.length > 0) return yield* Effect.fail(invalidConfig(`Unsupported root keys: ${unsupported.join(", ")}`));
+	const value = root;
+	if ([value.path !== void 0, value.nodeId !== void 0].filter(Boolean).length !== 1) return yield* Effect.fail(invalidConfig("A root must specify exactly one of path or nodeId"));
+	if (value.exportPrefix !== void 0 && (typeof value.exportPrefix !== "string" || value.exportPrefix.trim() === "")) return yield* Effect.fail(invalidConfig("root.exportPrefix must be a non-empty string"));
+	if (value.path !== void 0) {
+		const path = normalizePath(value.path, "root.path");
+		if (path instanceof Error) return yield* Effect.fail(invalidConfig(path.message));
+		return {
+			path,
+			exportPrefix: value.exportPrefix
+		};
+	}
+	if (typeof value.nodeId !== "string" || value.nodeId.trim() === "") return yield* Effect.fail(invalidConfig("root.nodeId must be a non-empty string"));
+	if (typeof value.exportPrefix !== "string" || value.exportPrefix.trim() === "") return yield* Effect.fail(invalidConfig("root.exportPrefix is required for nodeId roots"));
+	return {
+		nodeId: value.nodeId,
+		exportPrefix: value.exportPrefix
+	};
+});
+const normalizeExcludeRule = (rule) => Effect.gen(function* () {
+	if (!isRecord(rule)) return yield* Effect.fail(invalidConfig("Each exclude rule must be an object"));
+	const unsupported = unsupportedKeys(rule, ["path", "mode"]);
+	if (unsupported.length > 0) return yield* Effect.fail(invalidConfig(`Unsupported exclude keys: ${unsupported.join(", ")}`));
+	const value = rule;
+	if (value.mode !== "prune" && value.mode !== "omit") return yield* Effect.fail(invalidConfig("Each exclude rule must specify mode \"prune\" or \"omit\""));
+	if (value.path === void 0) return yield* Effect.fail(invalidConfig("Each exclude rule must specify path"));
+	const path = normalizeExcludePath(value.path);
+	if (path instanceof Error) return yield* Effect.fail(invalidConfig(path.message));
+	return path.some((segment) => segment instanceof RegExp || segment === "**") ? {
+		_tag: "PathPattern",
+		pathPattern: path,
+		mode: value.mode
+	} : {
+		_tag: "Path",
+		path,
+		mode: value.mode
+	};
+});
+const normalizeDiscovery = (value) => {
+	if (value === void 0) return { onBrowseFailure: "warn" };
+	if (!isRecord(value)) return /* @__PURE__ */ new Error("discovery must be an object");
+	const unsupported = unsupportedKeys(value, ["onBrowseFailure"]);
+	if (unsupported.length > 0) return /* @__PURE__ */ new Error(`Unsupported discovery keys: ${unsupported.join(", ")}`);
+	const onBrowseFailure = value.onBrowseFailure ?? "warn";
+	if (onBrowseFailure !== "warn" && onBrowseFailure !== "fail") return /* @__PURE__ */ new Error("discovery.onBrowseFailure must be \"warn\" or \"fail\"");
+	return { onBrowseFailure };
+};
+const normalizeDiagnostics = (value) => {
+	if (value === void 0) return {
+		warningsAsErrors: false,
+		typeFallback: "fail"
+	};
+	if (!isRecord(value)) return /* @__PURE__ */ new Error("diagnostics must be an object");
+	const unsupported = unsupportedKeys(value, ["warningsAsErrors", "typeFallback"]);
+	if (unsupported.length > 0) return /* @__PURE__ */ new Error(`Unsupported diagnostics keys: ${unsupported.join(", ")}`);
+	const warningsAsErrors = value.warningsAsErrors ?? false;
+	if (typeof warningsAsErrors !== "boolean") return /* @__PURE__ */ new Error("diagnostics.warningsAsErrors must be a boolean");
+	const typeFallback = value.typeFallback ?? "fail";
+	if (typeFallback !== "fail" && typeFallback !== "dynamic") return /* @__PURE__ */ new Error("diagnostics.typeFallback must be \"fail\" or \"dynamic\"");
+	return {
+		warningsAsErrors,
+		typeFallback
+	};
+};
+const normalizePath = (value, label) => {
+	if (!Array.isArray(value) || value.length === 0) return /* @__PURE__ */ new Error(`${label} must be a non-empty segment array`);
+	if (!value.every((segment) => typeof segment === "string" && segment.trim() !== "")) return /* @__PURE__ */ new Error(`${label} segments must be non-empty strings`);
+	return [...value];
+};
+const normalizeExcludePath = (value) => {
+	if (!Array.isArray(value) || value.length === 0) return /* @__PURE__ */ new Error("exclude.path must be a non-empty segment array");
+	if (!value.every((segment) => segment instanceof RegExp || typeof segment === "string" && segment.trim() !== "")) return /* @__PURE__ */ new Error("exclude.path segments must be non-empty strings, RegExp, or \"**\"");
+	return [...value];
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const unsupportedKeys = (record, supported) => Object.keys(record).filter((key) => !supported.includes(key));
+
+//#endregion
+export { defineConfig, loadConfig, normalizeConfig };
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../src/config.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport { Effect } from \"effect\";\nimport { unrun } from \"unrun\";\n\nimport { codegenError, invalidConfig } from \"./errors.js\";\nimport type {\n  CodegenConfig,\n  ExcludeRuleConfig,\n  PathPatternSegment,\n  RootConfig,\n} from \"./types.js\";\nimport type {\n  NormalizedCodegenConfig,\n  NormalizedExcludeRule,\n  NormalizedRootConfig,\n} from \"./internal/types.js\";\n\nexport const defineConfig = (config: CodegenConfig): CodegenConfig => config;\n\nexport const loadConfig = (\n  path = \"effect-opcua.codegen.ts\",\n): Effect.Effect<NormalizedCodegenConfig, import(\"./errors.js\").CodegenError> =>\n  Effect.gen(function* () {\n    const resolved = resolve(path);\n    const loaded = yield* Effect.tryPromise({\n      try: () => unrun({ path: resolved }),\n      catch: (cause) =>\n        codegenError({ _tag: \"Config\", path: resolved }, [\n          {\n            severity: \"error\",\n            code: \"config.loadFailed\",\n            message: `Failed to load config at ${resolved}`,\n            file: resolved,\n            cause,\n          },\n        ]),\n    });\n    const module = loaded.module as unknown;\n    const exportedConfig =\n      isRecord(module) && \"default\" in module ? module.default : module;\n    if (exportedConfig === undefined) {\n      return yield* Effect.fail(\n        codegenError({ _tag: \"Config\", path: resolved }, [\n          {\n            severity: \"error\",\n            code: \"config.loadFailed\",\n            message: \"Config module must have a default export\",\n            file: resolved,\n          },\n        ]),\n      );\n    }\n    return yield* normalizeConfig(exportedConfig);\n  });\n\nexport const normalizeConfig = (\n  config: unknown,\n): Effect.Effect<NormalizedCodegenConfig, import(\"./errors.js\").CodegenError> =>\n  Effect.gen(function* () {\n    if (!isRecord(config)) {\n      return yield* Effect.fail(invalidConfig(\"Config must be an object\"));\n    }\n    const unsupported = unsupportedKeys(config, [\n      \"endpointUrl\",\n      \"clientOptions\",\n      \"userIdentity\",\n      \"outputDir\",\n      \"roots\",\n      \"exclude\",\n      \"discovery\",\n      \"diagnostics\",\n    ]);\n    if (unsupported.length > 0) {\n      return yield* Effect.fail(\n        invalidConfig(`Unsupported config keys: ${unsupported.join(\", \")}`),\n      );\n    }\n\n    const endpointUrl = config.endpointUrl;\n    if (typeof endpointUrl !== \"string\" || endpointUrl.trim() === \"\") {\n      return yield* Effect.fail(invalidConfig(\"Missing endpointUrl\"));\n    }\n\n    const outputDir = config.outputDir;\n    if (typeof outputDir !== \"string\" || outputDir.trim() === \"\") {\n      return yield* Effect.fail(invalidConfig(\"Missing outputDir\"));\n    }\n\n    if (!Array.isArray(config.roots) || config.roots.length === 0) {\n      return yield* Effect.fail(\n        invalidConfig(\"Config roots must not be empty\"),\n      );\n    }\n    const roots = yield* Effect.forEach(config.roots, normalizeRoot);\n\n    const excludeInput = config.exclude ?? [];\n    if (!Array.isArray(excludeInput)) {\n      return yield* Effect.fail(invalidConfig(\"exclude must be an array\"));\n    }\n    const exclude = yield* Effect.forEach(excludeInput, normalizeExcludeRule);\n    const diagnostics = normalizeDiagnostics(config.diagnostics);\n    if (diagnostics instanceof Error) {\n      return yield* Effect.fail(invalidConfig(diagnostics.message));\n    }\n    const discovery = normalizeDiscovery(config.discovery);\n    if (discovery instanceof Error) {\n      return yield* Effect.fail(invalidConfig(discovery.message));\n    }\n\n    return {\n      endpointUrl,\n      clientOptions: config.clientOptions as\n        | NormalizedCodegenConfig[\"clientOptions\"]\n        | undefined,\n      userIdentity: config.userIdentity as\n        | NormalizedCodegenConfig[\"userIdentity\"]\n        | undefined,\n      outputDir,\n      roots,\n      exclude,\n      discovery,\n      diagnostics,\n    };\n  });\n\nconst normalizeRoot = (\n  root: unknown,\n): Effect.Effect<NormalizedRootConfig, import(\"./errors.js\").CodegenError> =>\n  Effect.gen(function* () {\n    if (!isRecord(root)) {\n      return yield* Effect.fail(invalidConfig(\"Each root must be an object\"));\n    }\n    const unsupported = unsupportedKeys(root, [\n      \"path\",\n      \"nodeId\",\n      \"exportPrefix\",\n    ]);\n    if (unsupported.length > 0) {\n      return yield* Effect.fail(\n        invalidConfig(`Unsupported root keys: ${unsupported.join(\", \")}`),\n      );\n    }\n    const value = root as RootConfig;\n    const descriptors = [\n      value.path !== undefined,\n      value.nodeId !== undefined,\n    ].filter(Boolean).length;\n    if (descriptors !== 1) {\n      return yield* Effect.fail(\n        invalidConfig(\"A root must specify exactly one of path or nodeId\"),\n      );\n    }\n    if (\n      value.exportPrefix !== undefined &&\n      (typeof value.exportPrefix !== \"string\" ||\n        value.exportPrefix.trim() === \"\")\n    ) {\n      return yield* Effect.fail(\n        invalidConfig(\"root.exportPrefix must be a non-empty string\"),\n      );\n    }\n    if (value.path !== undefined) {\n      const path = normalizePath(value.path, \"root.path\");\n      if (path instanceof Error)\n        return yield* Effect.fail(invalidConfig(path.message));\n      return { path, exportPrefix: value.exportPrefix };\n    }\n    if (typeof value.nodeId !== \"string\" || value.nodeId.trim() === \"\") {\n      return yield* Effect.fail(\n        invalidConfig(\"root.nodeId must be a non-empty string\"),\n      );\n    }\n    if (\n      typeof value.exportPrefix !== \"string\" ||\n      value.exportPrefix.trim() === \"\"\n    ) {\n      return yield* Effect.fail(\n        invalidConfig(\"root.exportPrefix is required for nodeId roots\"),\n      );\n    }\n    return { nodeId: value.nodeId, exportPrefix: value.exportPrefix };\n  });\n\nconst normalizeExcludeRule = (\n  rule: unknown,\n): Effect.Effect<NormalizedExcludeRule, import(\"./errors.js\").CodegenError> =>\n  Effect.gen(function* () {\n    if (!isRecord(rule)) {\n      return yield* Effect.fail(\n        invalidConfig(\"Each exclude rule must be an object\"),\n      );\n    }\n    const unsupported = unsupportedKeys(rule, [\"path\", \"mode\"]);\n    if (unsupported.length > 0) {\n      return yield* Effect.fail(\n        invalidConfig(`Unsupported exclude keys: ${unsupported.join(\", \")}`),\n      );\n    }\n    const value = rule as ExcludeRuleConfig;\n    if (value.mode !== \"prune\" && value.mode !== \"omit\") {\n      return yield* Effect.fail(\n        invalidConfig('Each exclude rule must specify mode \"prune\" or \"omit\"'),\n      );\n    }\n    if (value.path === undefined) {\n      return yield* Effect.fail(\n        invalidConfig(\"Each exclude rule must specify path\"),\n      );\n    }\n    const path = normalizeExcludePath(value.path);\n    if (path instanceof Error)\n      return yield* Effect.fail(invalidConfig(path.message));\n    return path.some((segment) => segment instanceof RegExp || segment === \"**\")\n      ? { _tag: \"PathPattern\", pathPattern: path, mode: value.mode }\n      : { _tag: \"Path\", path: path as readonly string[], mode: value.mode };\n  });\n\nconst normalizeDiscovery = (\n  value: unknown,\n): NormalizedCodegenConfig[\"discovery\"] | Error => {\n  if (value === undefined) {\n    return {\n      onBrowseFailure: \"warn\",\n    };\n  }\n  if (!isRecord(value)) return new Error(\"discovery must be an object\");\n  const unsupported = unsupportedKeys(value, [\"onBrowseFailure\"]);\n  if (unsupported.length > 0) {\n    return new Error(`Unsupported discovery keys: ${unsupported.join(\", \")}`);\n  }\n  const onBrowseFailure = value.onBrowseFailure ?? \"warn\";\n  if (onBrowseFailure !== \"warn\" && onBrowseFailure !== \"fail\") {\n    return new Error('discovery.onBrowseFailure must be \"warn\" or \"fail\"');\n  }\n  return { onBrowseFailure };\n};\n\nconst normalizeDiagnostics = (\n  value: unknown,\n): NormalizedCodegenConfig[\"diagnostics\"] | Error => {\n  if (value === undefined) {\n    return { warningsAsErrors: false, typeFallback: \"fail\" };\n  }\n  if (!isRecord(value)) return new Error(\"diagnostics must be an object\");\n  const unsupported = unsupportedKeys(value, [\n    \"warningsAsErrors\",\n    \"typeFallback\",\n  ]);\n  if (unsupported.length > 0) {\n    return new Error(`Unsupported diagnostics keys: ${unsupported.join(\", \")}`);\n  }\n  const warningsAsErrors = value.warningsAsErrors ?? false;\n  if (typeof warningsAsErrors !== \"boolean\") {\n    return new Error(\"diagnostics.warningsAsErrors must be a boolean\");\n  }\n  const typeFallback = value.typeFallback ?? \"fail\";\n  if (typeFallback !== \"fail\" && typeFallback !== \"dynamic\") {\n    return new Error('diagnostics.typeFallback must be \"fail\" or \"dynamic\"');\n  }\n  return { warningsAsErrors, typeFallback };\n};\n\nconst normalizePath = (\n  value: unknown,\n  label: string,\n): readonly string[] | Error => {\n  if (!Array.isArray(value) || value.length === 0) {\n    return new Error(`${label} must be a non-empty segment array`);\n  }\n  if (\n    !value.every(\n      (segment) => typeof segment === \"string\" && segment.trim() !== \"\",\n    )\n  ) {\n    return new Error(`${label} segments must be non-empty strings`);\n  }\n  return [...value];\n};\n\nconst normalizeExcludePath = (\n  value: unknown,\n): readonly PathPatternSegment[] | Error => {\n  if (!Array.isArray(value) || value.length === 0) {\n    return new Error(\"exclude.path must be a non-empty segment array\");\n  }\n  if (\n    !value.every(\n      (segment) =>\n        segment instanceof RegExp ||\n        (typeof segment === \"string\" && segment.trim() !== \"\"),\n    )\n  ) {\n    return new Error(\n      'exclude.path segments must be non-empty strings, RegExp, or \"**\"',\n    );\n  }\n  return [...value];\n};\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nconst unsupportedKeys = (\n  record: Record<string, unknown>,\n  supported: readonly string[],\n) => Object.keys(record).filter((key) => !supported.includes(key));\n"],"mappings":"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"}

package/dist/diagnostics.d.mts

@@ -0,0 +1,16 @@
+import { CodegenIssueCode } from "./issue-codes.mjs";
+import { CodegenIssue } from "./types.mjs";
+import { CodegenError } from "./errors.mjs";
+import { Effect } from "effect";
+
+//#region src/diagnostics.d.ts
+declare const issue: (code: CodegenIssueCode, input: Omit<CodegenIssue, "severity" | "code"> & {
+  readonly severity?: CodegenIssue["severity"];
+}) => CodegenIssue;
+declare const errorIssue: (code: CodegenIssueCode, input: Omit<CodegenIssue, "severity" | "code">) => CodegenIssue;
+declare const sortIssues: (issues: readonly CodegenIssue[]) => readonly CodegenIssue[];
+declare const enforceIssuePolicy: (warningsAsErrors: boolean, issues: readonly CodegenIssue[]) => Effect.Effect<never, CodegenError, never> | Effect.Effect<readonly CodegenIssue[], never, never>;
+declare const displayPath: (path: readonly string[] | undefined) => string;
+//#endregion
+export { displayPath, enforceIssuePolicy, errorIssue, issue, sortIssues };
+//# sourceMappingURL=diagnostics.d.mts.map

package/dist/diagnostics.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.mts","names":[],"sources":["../src/diagnostics.ts"],"sourcesContent":[],"mappings":";;;;;;cAMa,cACL,yBACC,KAAK;sBACU;MAErB;AALU,cAcA,UAFZ,EAAA,CAAA,IAAA,EAGO,gBAHP,EAAA,KAAA,EAIQ,IAJR,CAIa,YAJb,EAAA,UAAA,GAAA,MAAA,CAAA,EAAA,GAKE,YALF;AAXO,cAkBK,UAlBL,EAAA,CAAA,MAAA,EAAA,SAmBW,YAnBX,EAAA,EAAA,GAAA,SAoBI,YApBJ,EAAA;AACM,cAmCD,kBAnCC,EAAA,CAAA,gBAAA,EAAA,OAAA,EAAA,MAAA,EAAA,SAqCK,YArCL,EAAA,EAAA,GAqCmB,MAAA,CAAA,MArCnB,CAAA,KAAA,EAqCiB,YAAA,EArCjB,KAAA,CAAA,GAqCmB,MAAA,CAAA,MArCnB,CAAA,SAqCmB,YArCnB,EAAA,EAAA,KAAA,EAAA,KAAA,CAAA;AAAL,cAmDI,WAnDJ,EAAA,CAAA,IAAA,EAAA,SAAA,MAAA,EAAA,GAAA,SAAA,EAAA,GAAA,MAAA"}

package/dist/diagnostics.mjs

@@ -0,0 +1,45 @@
+import { codegenError } from "./errors.mjs";
+import { issueDefinitions } from "./issue-codes.mjs";
+import { Effect } from "effect";
+
+//#region src/diagnostics.ts
+const issue = (code, input) => {
+	const { severity, ...rest } = input;
+	return {
+		severity: severity ?? issueDefinitions[code].severity,
+		code,
+		...rest
+	};
+};
+const errorIssue = (code, input) => issue(code, {
+	...input,
+	severity: "error"
+});
+const sortIssues = (issues) => [...issues].sort((left, right) => [
+	severityRank(left.severity) - severityRank(right.severity),
+	displayPath(left.path).localeCompare(displayPath(right.path)),
+	displayPath(left.generatedPath).localeCompare(displayPath(right.generatedPath)),
+	(left.file ?? "").localeCompare(right.file ?? ""),
+	left.code.localeCompare(right.code),
+	(left.nodeId ?? "").localeCompare(right.nodeId ?? ""),
+	left.message.localeCompare(right.message)
+].find((value) => value !== 0) ?? 0);
+const enforceIssuePolicy = (warningsAsErrors, issues) => {
+	const promoted = warningsAsErrors ? issues.map((item) => item.severity === "warning" ? {
+		...item,
+		severity: "error"
+	} : item) : issues;
+	return promoted.some((item) => item.severity === "error") ? Effect.fail(codegenError({ _tag: "Compile" }, promoted)) : Effect.succeed(sortIssues(promoted));
+};
+const displayPath = (path) => path?.join(" / ") ?? "";
+const severityRank = (severity) => {
+	switch (severity) {
+		case "error": return 0;
+		case "warning": return 1;
+		case "info": return 2;
+	}
+};
+
+//#endregion
+export { displayPath, enforceIssuePolicy, errorIssue, issue, sortIssues };
+//# sourceMappingURL=diagnostics.mjs.map

package/dist/diagnostics.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.mjs","names":[],"sources":["../src/diagnostics.ts"],"sourcesContent":["import { Effect } from \"effect\";\n\nimport { codegenError } from \"./errors.js\";\nimport { issueDefinitions, type CodegenIssueCode } from \"./issue-codes.js\";\nimport type { CodegenIssue } from \"./types.js\";\n\nexport const issue = (\n  code: CodegenIssueCode,\n  input: Omit<CodegenIssue, \"severity\" | \"code\"> & {\n    readonly severity?: CodegenIssue[\"severity\"];\n  },\n): CodegenIssue => {\n  const { severity, ...rest } = input;\n  return {\n    severity: severity ?? issueDefinitions[code].severity,\n    code,\n    ...rest,\n  };\n};\n\nexport const errorIssue = (\n  code: CodegenIssueCode,\n  input: Omit<CodegenIssue, \"severity\" | \"code\">,\n): CodegenIssue => issue(code, { ...input, severity: \"error\" });\n\nexport const sortIssues = (\n  issues: readonly CodegenIssue[],\n): readonly CodegenIssue[] =>\n  [...issues].sort(\n    (left, right) =>\n      [\n        severityRank(left.severity) - severityRank(right.severity),\n        displayPath(left.path).localeCompare(displayPath(right.path)),\n        displayPath(left.generatedPath).localeCompare(\n          displayPath(right.generatedPath),\n        ),\n        (left.file ?? \"\").localeCompare(right.file ?? \"\"),\n        left.code.localeCompare(right.code),\n        (left.nodeId ?? \"\").localeCompare(right.nodeId ?? \"\"),\n        left.message.localeCompare(right.message),\n      ].find((value) => value !== 0) ?? 0,\n  );\n\nexport const enforceIssuePolicy = (\n  warningsAsErrors: boolean,\n  issues: readonly CodegenIssue[],\n) => {\n  const promoted = warningsAsErrors\n    ? issues.map((item) =>\n        item.severity === \"warning\"\n          ? { ...item, severity: \"error\" as const }\n          : item,\n      )\n    : issues;\n  return promoted.some((item) => item.severity === \"error\")\n    ? Effect.fail(codegenError({ _tag: \"Compile\" }, promoted))\n    : Effect.succeed(sortIssues(promoted));\n};\n\nexport const displayPath = (path: readonly string[] | undefined) =>\n  path?.join(\" / \") ?? \"\";\n\nconst severityRank = (severity: CodegenIssue[\"severity\"]) => {\n  switch (severity) {\n    case \"error\":\n      return 0;\n    case \"warning\":\n      return 1;\n    case \"info\":\n      return 2;\n  }\n};\n"],"mappings":";;;;;AAMA,MAAa,SACX,MACA,UAGiB;CACjB,MAAM,EAAE,UAAU,GAAG,SAAS;AAC9B,QAAO;EACL,UAAU,YAAY,iBAAiB,MAAM;EAC7C;EACA,GAAG;EACJ;;AAGH,MAAa,cACX,MACA,UACiB,MAAM,MAAM;CAAE,GAAG;CAAO,UAAU;CAAS,CAAC;AAE/D,MAAa,cACX,WAEA,CAAC,GAAG,OAAO,CAAC,MACT,MAAM,UACL;CACE,aAAa,KAAK,SAAS,GAAG,aAAa,MAAM,SAAS;CAC1D,YAAY,KAAK,KAAK,CAAC,cAAc,YAAY,MAAM,KAAK,CAAC;CAC7D,YAAY,KAAK,cAAc,CAAC,cAC9B,YAAY,MAAM,cAAc,CACjC;EACA,KAAK,QAAQ,IAAI,cAAc,MAAM,QAAQ,GAAG;CACjD,KAAK,KAAK,cAAc,MAAM,KAAK;EAClC,KAAK,UAAU,IAAI,cAAc,MAAM,UAAU,GAAG;CACrD,KAAK,QAAQ,cAAc,MAAM,QAAQ;CAC1C,CAAC,MAAM,UAAU,UAAU,EAAE,IAAI,EACrC;AAEH,MAAa,sBACX,kBACA,WACG;CACH,MAAM,WAAW,mBACb,OAAO,KAAK,SACV,KAAK,aAAa,YACd;EAAE,GAAG;EAAM,UAAU;EAAkB,GACvC,KACL,GACD;AACJ,QAAO,SAAS,MAAM,SAAS,KAAK,aAAa,QAAQ,GACrD,OAAO,KAAK,aAAa,EAAE,MAAM,WAAW,EAAE,SAAS,CAAC,GACxD,OAAO,QAAQ,WAAW,SAAS,CAAC;;AAG1C,MAAa,eAAe,SAC1B,MAAM,KAAK,MAAM,IAAI;AAEvB,MAAM,gBAAgB,aAAuC;AAC3D,SAAQ,UAAR;EACE,KAAK,QACH,QAAO;EACT,KAAK,UACH,QAAO;EACT,KAAK,OACH,QAAO"}

package/dist/discover.d.mts

@@ -0,0 +1,23 @@
+import { CodegenError } from "./errors.mjs";
+import { OpcuaError as OpcuaError$1 } from "./client/src/OpcuaError.mjs";
+import { Session } from "./client/src/OpcuaSession.mjs";
+import "./client/src/index.mjs";
+import { DiscoveryModel, NormalizedCodegenConfig, NormalizedExcludeRule } from "./internal/types.mjs";
+import { Context, Effect } from "effect";
+
+//#region src/discover.d.ts
+type OpcuaError = OpcuaError$1;
+type MetadataTargetReference = {
+  readonly nodeId: {
+    readonly text: string;
+  };
+  readonly browseName?: {
+    readonly name?: string;
+  };
+};
+type OpcuaSessionRequirement = Context.Service.Identifier<typeof Session>;
+declare const discover: (config: NormalizedCodegenConfig) => Effect.Effect<DiscoveryModel, CodegenError | OpcuaError, OpcuaSessionRequirement>;
+declare const metadataTargetNodeIds: (children: readonly MetadataTargetReference[], exclude: readonly NormalizedExcludeRule[], parentPath: readonly string[]) => string[];
+//#endregion
+export { discover, metadataTargetNodeIds };
+//# sourceMappingURL=discover.d.mts.map

package/dist/discover.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.mts","names":[],"sources":["../src/discover.ts"],"sourcesContent":[],"mappings":";;;;;;;;KA0BK,UAAA,GAAa;KAYb,uBAAA;;;EAZA,CAAA;EAYA,SAAA,UAAA,CAAA,EAAA;IAOA,SAAA,IAAA,CAAA,EAAA,MAAuB;EAaf,CAAA;CACH;KAdL,uBAAA,GAA0B,OAAA,CAAQ,OAAA,CAAQ,UAgB7C,CAAA,OAfO,OAeP,CAAA;AAAc,cAHH,QAGG,EAAA,CAAA,MAAA,EAFN,uBAEM,EAAA,GADb,MAAA,CAAO,MACM,CAAd,cAAc,EAAA,YAAA,GACuB,UADvB,EAEd,uBAFc,CAAA;AACuB,cAsV1B,qBAtV0B,EAAA,CAAA,QAAA,EAAA,SAuVlB,uBAvVkB,EAAA,EAAA,OAAA,EAAA,SAwVnB,qBAxVmB,EAAA,EAAA,UAAA,EAAA,SAAA,MAAA,EAAA,EAAA,GAAA,MAAA,EAAA"}

package/dist/discover.mjs

@@ -0,0 +1,356 @@
+import { codegenError } from "./errors.mjs";
+import { errorIssue, issue, sortIssues } from "./diagnostics.mjs";
+import { Effect } from "effect";
+import { OpcuaSession } from "@effect-opcua/client";
+
+//#region src/discover.ts
+const objectsFolderNodeId = "i=85";
+const allowedReferenceTypes = new Set([
+	"i=35",
+	"i=46",
+	"i=47",
+	"i=49"
+]);
+const metadataPropertyNames = new Set([
+	"InputArguments",
+	"OutputArguments",
+	"EnumStrings",
+	"EnumValues",
+	"DataTypeVersion",
+	"DictionaryFragment",
+	"NodeVersion"
+]);
+const discover = (config) => Effect.gen(function* () {
+	const session = yield* OpcuaSession.OpcuaSession;
+	const issues = [];
+	const references = [];
+	const nodes = /* @__PURE__ */ new Map();
+	const roots = [];
+	for (let rootIndex = 0; rootIndex < config.roots.length; rootIndex++) {
+		const rootConfig = config.roots[rootIndex];
+		const root = yield* resolveRoot(session, rootConfig, rootIndex);
+		roots.push({
+			...root,
+			exportPrefix: rootConfig.exportPrefix
+		});
+		addOrUpdateNode(nodes, {
+			metadata: yield* session.readNodeMetadata(root.nodeId),
+			path: root.path,
+			parentNodeId: void 0,
+			rootIndex,
+			rootSegmentCount: root.path.length
+		});
+	}
+	const queue = roots.map((root) => ({
+		nodeId: root.nodeId,
+		rootIndex: root.rootIndex,
+		rootSegmentCount: root.path.length,
+		path: root.path
+	}));
+	const visitedPaths = /* @__PURE__ */ new Set();
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const visitKey = `${current.nodeId}\u0000${current.path.join("\0")}`;
+		if (visitedPaths.has(visitKey)) continue;
+		visitedPaths.add(visitKey);
+		const result = yield* session.browseChildren(current.nodeId);
+		if (result._tag === "NonGoodStatus") {
+			const browseIssue = issue("browse.failure", {
+				message: `Could not browse ${current.nodeId}`,
+				nodeId: current.nodeId,
+				path: current.path,
+				cause: result.status,
+				severity: config.discovery.onBrowseFailure === "fail" ? "error" : void 0
+			});
+			if (browseIssue.severity === "error") return yield* Effect.fail(codegenError({ _tag: "Discovery" }, [browseIssue]));
+			issues.push(browseIssue);
+			continue;
+		}
+		const children = selectedChildReferences(result.references);
+		const duplicate = duplicateBrowseName(children);
+		if (duplicate) return yield* Effect.fail(codegenError({ _tag: "Discovery" }, [errorIssue("browse.ambiguousPath", {
+			message: "Multiple children have the same BrowseName segment",
+			path: [...current.path, duplicate.name],
+			cause: { candidates: duplicate.candidates }
+		})]));
+		const metadataByNodeId = yield* readChildMetadata(session, children, config.exclude, current.path);
+		for (const child of children) {
+			const browseName = child.browseName?.name;
+			const targetNodeId = child.nodeId.text;
+			if (!browseName || !targetNodeId) continue;
+			const referenceType = normalizeNamespaceZeroNodeId(child.referenceTypeId ?? "");
+			if (referenceType === "i=46" && metadataPropertyNames.has(browseName)) continue;
+			const childPath = [...current.path, browseName];
+			references.push({
+				sourceNodeId: current.nodeId,
+				targetNodeId,
+				referenceType,
+				isForward: child.isForward ?? true,
+				browseName
+			});
+			const exclude = matchingExclude(config.exclude, childPath);
+			if (exclude?.mode === "prune") {
+				issues.push(issue("branch.pruned", {
+					message: `Pruned ${displayPath(childPath)}`,
+					path: childPath,
+					nodeId: targetNodeId
+				}));
+				continue;
+			}
+			if (exclude?.mode !== "omit") {
+				const metadata = metadataByNodeId.get(targetNodeId);
+				if (!metadata) continue;
+				addOrUpdateNode(nodes, {
+					metadata,
+					path: childPath,
+					parentNodeId: current.nodeId,
+					rootIndex: current.rootIndex,
+					rootSegmentCount: current.rootSegmentCount
+				});
+			} else issues.push(issue("node.omitted", {
+				message: `Omitted ${displayPath(childPath)}`,
+				path: childPath,
+				nodeId: targetNodeId
+			}));
+			if (shouldBrowseChildren(child.nodeClass)) queue.push({
+				nodeId: targetNodeId,
+				parentNodeId: current.nodeId,
+				rootIndex: current.rootIndex,
+				rootSegmentCount: current.rootSegmentCount,
+				path: childPath
+			});
+		}
+	}
+	for (const node of nodes.values()) if (node.allPaths.length > 1) issues.push(issue("node.multiPath", {
+		message: `Node ${node.nodeId} was reached through multiple paths`,
+		path: node.path,
+		nodeId: node.nodeId
+	}));
+	const finalizedNodes = finalizeNodes(nodes);
+	const dataTypeDefinitions = yield* discoverDataTypeDefinitions(session, finalizedNodes);
+	return {
+		roots,
+		nodes: finalizedNodes,
+		references: sortReferences(references),
+		dataTypeDefinitions,
+		issues: sortIssues(issues)
+	};
+});
+const resolveRoot = (session, root, rootIndex) => root.nodeId !== void 0 ? resolveNodeIdRoot(session, root, rootIndex) : resolvePathRoot(session, root, rootIndex);
+const resolveNodeIdRoot = (session, root, rootIndex) => Effect.gen(function* () {
+	const browseName = (yield* session.readNodeMetadata(root.nodeId)).browseName ?? root.nodeId;
+	return {
+		rootIndex,
+		nodeId: root.nodeId,
+		path: [browseName],
+		exportPrefix: root.exportPrefix
+	};
+});
+const resolvePathRoot = (session, root, rootIndex) => Effect.gen(function* () {
+	let currentNodeId = objectsFolderNodeId;
+	const resolvedSegments = [];
+	for (const segment of root.path) {
+		const result = yield* session.browseChildren(currentNodeId);
+		if (result._tag === "NonGoodStatus") return yield* Effect.fail(codegenError({ _tag: "Discovery" }, [errorIssue("root.resolutionFailed", {
+			message: `Could not browse ${currentNodeId} while resolving ${displayPath(root.path)}`,
+			path: root.path,
+			nodeId: currentNodeId,
+			cause: result.status
+		})]));
+		const matches = selectedChildReferences(result.references).filter((reference) => reference.browseName?.name === segment);
+		if (matches.length === 0) return yield* Effect.fail(codegenError({ _tag: "Discovery" }, [errorIssue("root.resolutionFailed", {
+			message: `Missing root path segment ${segment}`,
+			path: [...resolvedSegments, segment]
+		})]));
+		if (matches.length > 1) return yield* Effect.fail(codegenError({ _tag: "Discovery" }, [errorIssue("browse.ambiguousPath", {
+			message: "Multiple children match the root path segment",
+			path: [...resolvedSegments, segment],
+			cause: { candidates: matches.map((match) => match.nodeId.text) }
+		})]));
+		currentNodeId = matches[0].nodeId.text;
+		resolvedSegments.push(segment);
+	}
+	return {
+		rootIndex,
+		nodeId: currentNodeId,
+		path: resolvedSegments,
+		exportPrefix: root.exportPrefix
+	};
+});
+const selectedChildReferences = (references) => references.filter((reference) => reference.isForward !== false).filter((reference) => allowedReferenceTypes.has(normalizeNamespaceZeroNodeId(reference.referenceTypeId ?? ""))).sort(referenceSort);
+const duplicateBrowseName = (references) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const reference of references) {
+		const name = reference.browseName?.name;
+		if (!name) continue;
+		const group = groups.get(name) ?? [];
+		group.push(reference.nodeId.text);
+		groups.set(name, group);
+	}
+	for (const [name, candidates] of groups) if (candidates.length > 1) return {
+		name,
+		candidates
+	};
+};
+const referenceSort = (left, right) => (left.browseName?.name ?? "").localeCompare(right.browseName?.name ?? "") || (left.nodeClass ?? "").localeCompare(right.nodeClass ?? "") || left.nodeId.text.localeCompare(right.nodeId.text);
+const matchingExclude = (rules, path) => rules.find((rule) => rule._tag === "Path" ? samePath(rule.path, path) : matchPathPattern(rule.pathPattern, path));
+const readChildMetadata = (session, children, exclude, parentPath) => Effect.gen(function* () {
+	const metadataTargets = metadataTargetNodeIds(children, exclude, parentPath);
+	if (metadataTargets.length === 0) return /* @__PURE__ */ new Map();
+	const results = yield* session.readManyNodeMetadata(metadataTargets);
+	const failed = results.find((result) => result._tag === "Failure");
+	if (failed?._tag === "Failure") return yield* Effect.fail(codegenError({ _tag: "Discovery" }, [errorIssue("metadata.readFailed", {
+		message: `Could not read metadata for ${failed.nodeId}`,
+		nodeId: failed.nodeId,
+		cause: failed.reason
+	})]));
+	return new Map(results.flatMap((result) => result._tag === "Success" ? [[result.nodeId, result.metadata]] : []));
+});
+const metadataTargetNodeIds = (children, exclude, parentPath) => children.flatMap((child) => {
+	const browseName = child.browseName?.name;
+	const targetNodeId = child.nodeId.text;
+	if (!browseName || !targetNodeId) return [];
+	return matchingExclude(exclude, [...parentPath, browseName]) ? [] : [targetNodeId];
+});
+const matchPathPattern = (pattern, path) => {
+	const match = (patternIndex, pathIndex) => {
+		if (patternIndex === pattern.length) return pathIndex === path.length;
+		const segment = pattern[patternIndex];
+		if (segment === "**") return match(patternIndex + 1, pathIndex) || pathIndex < path.length && match(patternIndex, pathIndex + 1);
+		if (pathIndex >= path.length) return false;
+		return segmentMatches(segment, path[pathIndex]) && match(patternIndex + 1, pathIndex + 1);
+	};
+	return match(0, 0);
+};
+const segmentMatches = (pattern, segment) => pattern instanceof RegExp ? pattern.test(segment) : pattern === segment;
+const samePath = (left, right) => left.length === right.length && left.every((segment, index) => segment === right[index]);
+const addOrUpdateNode = (nodes, input) => {
+	const key = input.metadata.nodeId;
+	const existing = nodes.get(key);
+	if (existing) {
+		const allPaths = uniquePaths([...existing.allPaths, input.path]);
+		if (comparePathRank({
+			rootIndex: input.rootIndex,
+			rootSegmentCount: input.rootSegmentCount,
+			path: input.path,
+			nodeId: key
+		}, {
+			rootIndex: existing.rootIndex ?? Number.MAX_SAFE_INTEGER,
+			rootSegmentCount: existing.rootSegmentCount,
+			path: existing.path,
+			nodeId: existing.nodeId
+		}) < 0) nodes.set(key, {
+			...existing,
+			path: input.path,
+			allPaths,
+			parentNodeId: input.parentNodeId,
+			rootIndex: input.rootIndex,
+			rootSegmentCount: input.rootSegmentCount
+		});
+		else nodes.set(key, {
+			...existing,
+			allPaths
+		});
+		return;
+	}
+	const nodeClass = normalizeNodeClass(input.metadata.nodeClass);
+	if (!nodeClass) return;
+	nodes.set(key, {
+		key,
+		nodeId: key,
+		parsedNodeId: parseNodeId(key, input.metadata.namespaceIndex),
+		namespaceIndex: input.metadata.namespaceIndex ?? parseNodeId(key).namespaceIndex,
+		namespaceUri: input.metadata.namespaceUri,
+		browseName: input.metadata.browseName ?? input.path.at(-1) ?? key,
+		browseNameNamespaceIndex: input.metadata.browseNameNamespaceIndex,
+		path: input.path,
+		allPaths: [input.path],
+		nodeClass,
+		displayName: input.metadata.displayName,
+		description: input.metadata.description,
+		dataTypeNodeId: input.metadata.dataType,
+		valueRank: input.metadata.valueRank,
+		arrayDimensions: input.metadata.arrayDimensions,
+		accessLevel: input.metadata.accessLevel,
+		userAccessLevel: input.metadata.userAccessLevel,
+		parentNodeId: input.parentNodeId,
+		rootIndex: input.rootIndex,
+		rootSegmentCount: input.rootSegmentCount
+	});
+};
+const normalizeNodeClass = (nodeClass) => {
+	switch (nodeClass) {
+		case "Object":
+		case "Variable":
+		case "Method":
+		case "DataType":
+		case "ObjectType":
+		case "VariableType":
+		case "ReferenceType": return nodeClass;
+		default: return;
+	}
+};
+const shouldBrowseChildren = (nodeClass) => nodeClass === "Object";
+const discoverDataTypeDefinitions = (session, nodes) => Effect.gen(function* () {
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [...nodes.values()].filter((node) => node.nodeClass === "Variable").flatMap((node) => node.dataTypeNodeId ? [node.dataTypeNodeId] : []).filter((nodeId) => !isBuiltInDataType(nodeId));
+	const results = [];
+	while (queue.length > 0) {
+		const batch = [...new Set(queue.splice(0))].filter((nodeId) => !seen.has(nodeId)).sort();
+		if (batch.length === 0) continue;
+		batch.forEach((nodeId) => seen.add(nodeId));
+		const batchResults = yield* session.readManyDataTypeDefinitions(batch);
+		results.push(...batchResults);
+		for (const result of batchResults) {
+			if (result._tag !== "Success" || result.definition._tag !== "Structure") continue;
+			for (const field of result.definition.fields) if (field.dataTypeNodeId && !isBuiltInDataType(field.dataTypeNodeId) && !seen.has(field.dataTypeNodeId)) queue.push(field.dataTypeNodeId);
+		}
+	}
+	return results;
+});
+const isBuiltInDataType = (nodeId) => {
+	const normalized = normalizeNamespaceZeroNodeId(nodeId);
+	return /^i=\d+$/.test(normalized);
+};
+const parseNodeId = (nodeId, namespaceIndex) => {
+	const match = /^ns=(\d+);(.+)$/.exec(nodeId);
+	return {
+		namespaceIndex: namespaceIndex ?? (match ? Number(match[1]) : 0),
+		identifier: match?.[2] ?? nodeId
+	};
+};
+const comparePathRank = (left, right) => left.rootIndex - right.rootIndex || relativeLength(left) - relativeLength(right) || displayPath(left.path).localeCompare(displayPath(right.path)) || left.nodeId.localeCompare(right.nodeId);
+const relativeLength = (item) => item.path.length - item.rootSegmentCount;
+const finalizeNodes = (nodes) => {
+	const entries = [];
+	for (const [key, node] of nodes) entries.push([key, {
+		key: node.key,
+		nodeId: node.nodeId,
+		parsedNodeId: node.parsedNodeId,
+		namespaceIndex: node.namespaceIndex,
+		namespaceUri: node.namespaceUri,
+		browseName: node.browseName,
+		browseNameNamespaceIndex: node.browseNameNamespaceIndex,
+		path: node.path,
+		allPaths: uniquePaths(node.allPaths),
+		nodeClass: node.nodeClass,
+		displayName: node.displayName,
+		description: node.description,
+		dataTypeNodeId: node.dataTypeNodeId,
+		valueRank: node.valueRank,
+		arrayDimensions: node.arrayDimensions,
+		accessLevel: node.accessLevel,
+		userAccessLevel: node.userAccessLevel,
+		parentNodeId: node.parentNodeId,
+		rootIndex: node.rootIndex
+	}]);
+	return new Map(entries.sort((left, right) => displayPath(left[1].path).localeCompare(displayPath(right[1].path))));
+};
+const uniquePaths = (paths) => [...new Map(paths.map((path) => [path.join("\0"), [...path]])).values()].sort((left, right) => displayPath(left).localeCompare(displayPath(right)));
+const sortReferences = (references) => [...references].sort((left, right) => left.sourceNodeId.localeCompare(right.sourceNodeId) || left.browseName.localeCompare(right.browseName) || left.targetNodeId.localeCompare(right.targetNodeId));
+const displayPath = (path) => path.join(" / ");
+const normalizeNamespaceZeroNodeId = (nodeId) => nodeId.startsWith("ns=0;") ? nodeId.slice(5) : nodeId;
+
+//#endregion
+export { discover, metadataTargetNodeIds };
+//# sourceMappingURL=discover.mjs.map