node-opcua-alias-name-server 2.176.0

package/dist/bind_find_alias.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module node-opcua-alias-name-server
+ *
+ * The `FindAlias` (clause 6.3.2) and `FindAliasVerbose` (clause 6.3.3) Method
+ * handlers.
+ *
+ * The two Methods are identical in every respect except the DataType they
+ * return, so both are produced from one implementation: whatever the FindAlias
+ * suite proves is proved for FindAliasVerbose too.
+ */
+import type { ISessionContext, UAMethod } from "node-opcua-address-space-base";
+import { type AliasEntry, type IAliasStore } from "node-opcua-alias-name-common";
+import { type NodeId } from "node-opcua-nodeid";
+import type { CallMethodResultOptions } from "node-opcua-service-call";
+import { type Variant } from "node-opcua-variant";
+/**
+ * Orders results before they are returned.
+ *
+ * Clause 6.3.2 requires the Server to return "what it recommends as the best
+ * match first", and says the criteria are Server specific — the examples it
+ * gives (ServerStatus of the Server holding the Node, load balancing) only mean
+ * anything once more than one Server is involved. A Server publishing its own
+ * aliases has no basis to prefer one of its own Nodes over another, so the
+ * default preserves discovery order, which is at least deterministic and
+ * therefore stable across calls. Replace it when the Server does have a basis.
+ */
+export type AliasComparator = (a: AliasEntry, b: AliasEntry) => number;
+/** The default: keep discovery order (a stable no-op comparator). */
+export declare const insertionOrderComparator: AliasComparator;
+export interface FindAliasBindingOptions {
+    /** Where the aliases come from. */
+    store: IAliasStore;
+    /**
+     * Beyond this many results the call fails with `Bad_ResponseTooLarge`
+     * (clause 6.3.2 Table 4).
+     */
+    maxResults: number;
+    /** Result ordering; defaults to {@link insertionOrderComparator}. */
+    comparator?: AliasComparator;
+    /**
+     * Read gate. Return false to answer `Bad_UserAccessDenied`
+     * (clause 6.3.2 Table 4). Defaults to allowing everyone, matching a Server
+     * that publishes its aliases openly.
+     *
+     * Receives the category the Method was called on, so a Server with
+     * per-customer or per-tenant categories can answer "may this user see *this*
+     * category" rather than only "may this user read aliases at all". May return
+     * a Promise: the handler is async anyway, so a permission lookup that hits a
+     * database costs nothing structurally.
+     */
+    isReadAllowed?: (context: ISessionContext, categoryNodeId: NodeId) => boolean | Promise<boolean>;
+}
+/**
+ * Build a handler for `FindAlias` or `FindAliasVerbose`.
+ *
+ * `this` is the Method node, so the category searched is the Method's parent —
+ * that is what makes one handler serve every instance of
+ * `AliasNameCategoryType`, including vendor subcategories created through the
+ * `<SubAliasNameCategories>` placeholder.
+ */
+export declare function makeFindAliasHandler(options: FindAliasBindingOptions, verbose: boolean): (this: UAMethod, inputArguments: Variant[], context: ISessionContext) => Promise<CallMethodResultOptions>;

package/dist/bind_find_alias.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * @module node-opcua-alias-name-server
+ *
+ * The `FindAlias` (clause 6.3.2) and `FindAliasVerbose` (clause 6.3.3) Method
+ * handlers.
+ *
+ * The two Methods are identical in every respect except the DataType they
+ * return, so both are produced from one implementation: whatever the FindAlias
+ * suite proves is proved for FindAliasVerbose too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertionOrderComparator = void 0;
+exports.makeFindAliasHandler = makeFindAliasHandler;
+const node_opcua_alias_name_common_1 = require("node-opcua-alias-name-common");
+const node_opcua_nodeid_1 = require("node-opcua-nodeid");
+const node_opcua_status_code_1 = require("node-opcua-status-code");
+const node_opcua_types_1 = require("node-opcua-types");
+const node_opcua_variant_1 = require("node-opcua-variant");
+/** The default: keep discovery order (a stable no-op comparator). */
+const insertionOrderComparator = () => 0;
+exports.insertionOrderComparator = insertionOrderComparator;
+/** Read `AliasNameSearchPattern` (argument 0). */
+function readPattern(inputArguments) {
+    const value = inputArguments?.[0]?.value;
+    if (value === null || value === undefined) {
+        // clause 6.3.2 gives no meaning to a null pattern; treat it as "match
+        // everything" would silently dump the whole hierarchy, so reject it
+        return null;
+    }
+    return typeof value === "string" ? value : null;
+}
+/** Read `ReferenceTypeFilter` (argument 1). */
+function readReferenceTypeFilter(inputArguments) {
+    const value = inputArguments?.[1]?.value;
+    return value instanceof node_opcua_nodeid_1.NodeId ? value : undefined;
+}
+/**
+ * Merge entries that share an AliasName.
+ *
+ * `AliasNameDataType` is "an array of ExpandedNodeId for a single AliasName"
+ * (clause 7.2), so the non-verbose Method reports one entry per distinct name
+ * with all of its targets. The verbose form does *not* merge: its
+ * `AliasNameCategoryId` names the category that held the alias, which differs
+ * between entries.
+ */
+function mergeByAliasName(entries) {
+    const byName = new Map();
+    // Membership is kept in a Set per name rather than rescanning the growing
+    // array: with a linear scan, a name shared by many entries makes this
+    // quadratic in the size of the result set.
+    const seenTargets = new Map();
+    for (const entry of entries) {
+        const existing = byName.get(entry.aliasName);
+        if (!existing) {
+            byName.set(entry.aliasName, { ...entry, referencedNodes: [...entry.referencedNodes] });
+            seenTargets.set(entry.aliasName, new Set(entry.referencedNodes.map((n) => n.toString())));
+            continue;
+        }
+        // written alongside byName above, so it is always present
+        const seen = seenTargets.get(entry.aliasName) ?? new Set();
+        seenTargets.set(entry.aliasName, seen);
+        for (const node of entry.referencedNodes) {
+            const key = node.toString();
+            if (!seen.has(key)) {
+                seen.add(key);
+                existing.referencedNodes.push(node);
+            }
+        }
+    }
+    return [...byName.values()];
+}
+/**
+ * Resolve each entry's AliasName namespace index, once per call.
+ *
+ * The namespace reported is the one the alias was published in, taken from the
+ * store. Using the *category's* namespace instead would put every alias on the
+ * three well-known categories into namespace 0, which is reserved for the OPC
+ * Foundation and is not what clause 6.2 intends. A store that does not know its
+ * namespace falls back to the Server's own, never to 0.
+ *
+ * Clients ignore the namespace when comparing AliasNames (clause 6.2), so this
+ * is not a matching concern — it is a matter of reporting truthfully.
+ */
+function makeNamespaceResolver(category) {
+    const addressSpace = category.addressSpace;
+    const ownNamespaceIndex = addressSpace.getOwnNamespace().index;
+    const cache = new Map();
+    return (entry) => {
+        if (!entry.aliasNameNamespaceUri) {
+            return ownNamespaceIndex;
+        }
+        const cached = cache.get(entry.aliasNameNamespaceUri);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const index = addressSpace.getNamespaceIndex(entry.aliasNameNamespaceUri);
+        // an unregistered URI resolves to -1; reporting the Server's own
+        // namespace is closer to the truth than reporting namespace 0
+        const resolved = index >= 0 ? index : ownNamespaceIndex;
+        cache.set(entry.aliasNameNamespaceUri, resolved);
+        return resolved;
+    };
+}
+/**
+ * Build a handler for `FindAlias` or `FindAliasVerbose`.
+ *
+ * `this` is the Method node, so the category searched is the Method's parent —
+ * that is what makes one handler serve every instance of
+ * `AliasNameCategoryType`, including vendor subcategories created through the
+ * `<SubAliasNameCategories>` placeholder.
+ */
+function makeFindAliasHandler(options, verbose) {
+    const comparator = options.comparator ?? exports.insertionOrderComparator;
+    return async function findAliasHandler(inputArguments, context) {
+        const category = this.parent;
+        if (!category) {
+            return { statusCode: node_opcua_status_code_1.StatusCodes.BadInternalError };
+        }
+        // The gate is consulted per category, and each category at most once per
+        // call. Memoised because a recursive search reaches the same category
+        // through every alias it holds, and the rule may hit a database.
+        const gate = options.isReadAllowed;
+        const decisions = new Map();
+        const mayRead = async (categoryNodeId) => {
+            if (!gate) {
+                return true;
+            }
+            const key = categoryNodeId.toString();
+            const cached = decisions.get(key);
+            if (cached !== undefined) {
+                return cached;
+            }
+            const allowed = await gate(context, categoryNodeId);
+            decisions.set(key, allowed);
+            return allowed;
+        };
+        // A direct call on a category the caller may not read is
+        // Bad_UserAccessDenied: there is nothing left to filter, so silence
+        // would be a lie rather than a non-disclosure.
+        if (!(await mayRead(category.nodeId))) {
+            return { statusCode: node_opcua_status_code_1.StatusCodes.BadUserAccessDenied };
+        }
+        const pattern = readPattern(inputArguments);
+        if (pattern === null) {
+            return { statusCode: node_opcua_status_code_1.StatusCodes.BadInvalidArgument };
+        }
+        const query = {
+            pattern,
+            referenceTypeFilter: readReferenceTypeFilter(inputArguments),
+            categoryNodeId: category.nodeId,
+            maxResults: options.maxResults,
+            // Handed the same memoised closure the filter below uses, so the
+            // rule is evaluated at most once per category per call however many
+            // times it is consulted. Passed only when a gate is configured, so
+            // an ungated Server takes exactly the path it took before.
+            isVisible: gate ? mayRead : undefined
+        };
+        let found;
+        try {
+            found = await options.store.find(query);
+        }
+        catch (err) {
+            if (err instanceof node_opcua_alias_name_common_1.InvalidLikePatternError) {
+                // clause 6.3.2 Table 4: "The input string is not a valid search string"
+                return { statusCode: node_opcua_status_code_1.StatusCodes.BadInvalidArgument };
+            }
+            throw err;
+        }
+        // clause 6.3.2 Table 4: too large to return, "try new filter and repeat find".
+        //
+        // Applied to what the store produced, *before* filtering and merging.
+        // The store stops collecting one entry past the cap, so a count that
+        // reaches it means "there may be more"; reducing the count first would
+        // report a truncated scan as a complete answer. The code names no
+        // category, so it discloses nothing a gated caller should not see.
+        if (found.length > options.maxResults) {
+            return { statusCode: node_opcua_status_code_1.StatusCodes.BadResponseTooLarge };
+        }
+        // A nested category the caller may not read is omitted, and the call
+        // still succeeds: an error, or a count that changed, would confirm the
+        // category exists. Absence is the only answer that discloses nothing.
+        //
+        // The store was given the same predicate and should already have skipped
+        // these, so this is normally a no-op. It stays as a backstop: an injected
+        // store written by someone else may ignore `isVisible`, and the cost of
+        // that must be a wasted scan, never a leak.
+        const visible = [];
+        for (const entry of found) {
+            if (await mayRead(entry.categoryNodeId)) {
+                visible.push(entry);
+            }
+        }
+        // Filtering happens before the verbose/plain split, so FindAliasVerbose
+        // cannot reveal a ServerUri or an AliasNameCategoryId for a category
+        // that FindAlias would have hidden.
+        const results = verbose ? visible : mergeByAliasName(visible);
+        // sort() is stable in modern JavaScript, so a comparator that returns 0
+        // leaves discovery order untouched
+        const ordered = [...results].sort(comparator);
+        // No match is Good with an empty AliasNodeList (clause 6.3.2 Table 3),
+        // never an error.
+        const namespaceIndexOf = makeNamespaceResolver(category);
+        const value = verbose
+            ? ordered.map((entry) => new node_opcua_types_1.AliasNameVerboseDataType({
+                aliasName: { name: entry.aliasName, namespaceIndex: namespaceIndexOf(entry) },
+                referencedNodes: entry.referencedNodes,
+                serverUris: entry.serverUris,
+                aliasNameCategoryId: entry.categoryNodeId
+            }))
+            : ordered.map((entry) => new node_opcua_types_1.AliasNameDataType({
+                aliasName: { name: entry.aliasName, namespaceIndex: namespaceIndexOf(entry) },
+                referencedNodes: entry.referencedNodes
+            }));
+        return {
+            statusCode: node_opcua_status_code_1.StatusCodes.Good,
+            outputArguments: [
+                {
+                    dataType: node_opcua_variant_1.DataType.ExtensionObject,
+                    arrayType: node_opcua_variant_1.VariantArrayType.Array,
+                    value
+                }
+            ]
+        };
+    };
+}
+//# sourceMappingURL=bind_find_alias.js.map

package/dist/bind_find_alias.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind_find_alias.js","sourceRoot":"","sources":["../source/bind_find_alias.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @module node-opcua-alias-name-server
+ *
+ * Server-side OPC 10000-17 (AliasNames).
+ *
+ * Publishes **this Server's own** AliasNames. Aggregating AliasNames collected
+ * from other Servers (Annex B, Annex C) and the Annex D PubSub change
+ * notification are out of scope.
+ */
+export { type AddAliasOptions, AliasNameError, addAlias, findAlias, removeAlias } from "./add_alias.js";
+export { AddressSpaceAliasStore, type AddressSpaceAliasStoreOptions } from "./address_space_alias_store.js";
+export { aliasesOf, collectAllCategories, collectCategories, findAliasNameCategoryType, findAliasNameType, isAliasName, isAliasNameCategory, presentWellKnownCategories } from "./alias_hierarchy.js";
+export { ALIAS_NAME_ARCHIVE_VERSION, type AliasNameArchive, readAliasNameArchive, writeAliasNameArchive } from "./alias_name_archive.js";
+export { type AddAliasCategoryOptions, addAliasCategory, type BindAliasCategoryOptions, bindAliasCategory, ensureLastChangeProperty, ensureOptionalMethod, findMethodByDeclaration, getInstalledAliasNames, type InstalledAliasNames, removeAliasCategory } from "./bind_alias_category.js";
+export { type AliasComparator, type FindAliasBindingOptions, insertionOrderComparator, makeFindAliasHandler } from "./bind_find_alias.js";
+export { ALIAS_SERVER_CAPABILITY_ID, advertiseAliasCapability, type CategoryProvider, DEFAULT_MAX_RESULTS, defaultCategoryProvider, type InstallAliasNamesOptions, type InstallAliasNamesResult, type IServerForAliasNames, installAliasNames, installAliasNamesOnAddressSpace } from "./install_alias_names.js";
+export { LAST_CHANGE_BROWSE_NAME, LastChangeTracker, type LastChangeTrackerOptions } from "./last_change.js";
+export { ALIAS_FOR, ALIAS_NAME_CATEGORY_TYPE, ALIAS_NAME_TYPE, ALIAS_SERVER_CAPABILITY, MethodDeclarations, PUBLISHED_DATA_SET_TYPE, WellKnownCategories, WellKnownLastChange, WellKnownOptionalMethods } from "./well_known.js";

package/dist/index.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * @module node-opcua-alias-name-server
+ *
+ * Server-side OPC 10000-17 (AliasNames).
+ *
+ * Publishes **this Server's own** AliasNames. Aggregating AliasNames collected
+ * from other Servers (Annex B, Annex C) and the Annex D PubSub change
+ * notification are out of scope.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellKnownOptionalMethods = exports.WellKnownLastChange = exports.WellKnownCategories = exports.PUBLISHED_DATA_SET_TYPE = exports.MethodDeclarations = exports.ALIAS_SERVER_CAPABILITY = exports.ALIAS_NAME_TYPE = exports.ALIAS_NAME_CATEGORY_TYPE = exports.ALIAS_FOR = exports.LastChangeTracker = exports.LAST_CHANGE_BROWSE_NAME = exports.installAliasNamesOnAddressSpace = exports.installAliasNames = exports.defaultCategoryProvider = exports.DEFAULT_MAX_RESULTS = exports.advertiseAliasCapability = exports.ALIAS_SERVER_CAPABILITY_ID = exports.makeFindAliasHandler = exports.insertionOrderComparator = exports.removeAliasCategory = exports.getInstalledAliasNames = exports.findMethodByDeclaration = exports.ensureOptionalMethod = exports.ensureLastChangeProperty = exports.bindAliasCategory = exports.addAliasCategory = exports.writeAliasNameArchive = exports.readAliasNameArchive = exports.ALIAS_NAME_ARCHIVE_VERSION = exports.presentWellKnownCategories = exports.isAliasNameCategory = exports.isAliasName = exports.findAliasNameType = exports.findAliasNameCategoryType = exports.collectCategories = exports.collectAllCategories = exports.aliasesOf = exports.AddressSpaceAliasStore = exports.removeAlias = exports.findAlias = exports.addAlias = exports.AliasNameError = void 0;
+var add_alias_js_1 = require("./add_alias.js");
+Object.defineProperty(exports, "AliasNameError", { enumerable: true, get: function () { return add_alias_js_1.AliasNameError; } });
+Object.defineProperty(exports, "addAlias", { enumerable: true, get: function () { return add_alias_js_1.addAlias; } });
+Object.defineProperty(exports, "findAlias", { enumerable: true, get: function () { return add_alias_js_1.findAlias; } });
+Object.defineProperty(exports, "removeAlias", { enumerable: true, get: function () { return add_alias_js_1.removeAlias; } });
+var address_space_alias_store_js_1 = require("./address_space_alias_store.js");
+Object.defineProperty(exports, "AddressSpaceAliasStore", { enumerable: true, get: function () { return address_space_alias_store_js_1.AddressSpaceAliasStore; } });
+var alias_hierarchy_js_1 = require("./alias_hierarchy.js");
+Object.defineProperty(exports, "aliasesOf", { enumerable: true, get: function () { return alias_hierarchy_js_1.aliasesOf; } });
+Object.defineProperty(exports, "collectAllCategories", { enumerable: true, get: function () { return alias_hierarchy_js_1.collectAllCategories; } });
+Object.defineProperty(exports, "collectCategories", { enumerable: true, get: function () { return alias_hierarchy_js_1.collectCategories; } });
+Object.defineProperty(exports, "findAliasNameCategoryType", { enumerable: true, get: function () { return alias_hierarchy_js_1.findAliasNameCategoryType; } });
+Object.defineProperty(exports, "findAliasNameType", { enumerable: true, get: function () { return alias_hierarchy_js_1.findAliasNameType; } });
+Object.defineProperty(exports, "isAliasName", { enumerable: true, get: function () { return alias_hierarchy_js_1.isAliasName; } });
+Object.defineProperty(exports, "isAliasNameCategory", { enumerable: true, get: function () { return alias_hierarchy_js_1.isAliasNameCategory; } });
+Object.defineProperty(exports, "presentWellKnownCategories", { enumerable: true, get: function () { return alias_hierarchy_js_1.presentWellKnownCategories; } });
+var alias_name_archive_js_1 = require("./alias_name_archive.js");
+Object.defineProperty(exports, "ALIAS_NAME_ARCHIVE_VERSION", { enumerable: true, get: function () { return alias_name_archive_js_1.ALIAS_NAME_ARCHIVE_VERSION; } });
+Object.defineProperty(exports, "readAliasNameArchive", { enumerable: true, get: function () { return alias_name_archive_js_1.readAliasNameArchive; } });
+Object.defineProperty(exports, "writeAliasNameArchive", { enumerable: true, get: function () { return alias_name_archive_js_1.writeAliasNameArchive; } });
+var bind_alias_category_js_1 = require("./bind_alias_category.js");
+Object.defineProperty(exports, "addAliasCategory", { enumerable: true, get: function () { return bind_alias_category_js_1.addAliasCategory; } });
+Object.defineProperty(exports, "bindAliasCategory", { enumerable: true, get: function () { return bind_alias_category_js_1.bindAliasCategory; } });
+Object.defineProperty(exports, "ensureLastChangeProperty", { enumerable: true, get: function () { return bind_alias_category_js_1.ensureLastChangeProperty; } });
+Object.defineProperty(exports, "ensureOptionalMethod", { enumerable: true, get: function () { return bind_alias_category_js_1.ensureOptionalMethod; } });
+Object.defineProperty(exports, "findMethodByDeclaration", { enumerable: true, get: function () { return bind_alias_category_js_1.findMethodByDeclaration; } });
+Object.defineProperty(exports, "getInstalledAliasNames", { enumerable: true, get: function () { return bind_alias_category_js_1.getInstalledAliasNames; } });
+Object.defineProperty(exports, "removeAliasCategory", { enumerable: true, get: function () { return bind_alias_category_js_1.removeAliasCategory; } });
+var bind_find_alias_js_1 = require("./bind_find_alias.js");
+Object.defineProperty(exports, "insertionOrderComparator", { enumerable: true, get: function () { return bind_find_alias_js_1.insertionOrderComparator; } });
+Object.defineProperty(exports, "makeFindAliasHandler", { enumerable: true, get: function () { return bind_find_alias_js_1.makeFindAliasHandler; } });
+var install_alias_names_js_1 = require("./install_alias_names.js");
+Object.defineProperty(exports, "ALIAS_SERVER_CAPABILITY_ID", { enumerable: true, get: function () { return install_alias_names_js_1.ALIAS_SERVER_CAPABILITY_ID; } });
+Object.defineProperty(exports, "advertiseAliasCapability", { enumerable: true, get: function () { return install_alias_names_js_1.advertiseAliasCapability; } });
+Object.defineProperty(exports, "DEFAULT_MAX_RESULTS", { enumerable: true, get: function () { return install_alias_names_js_1.DEFAULT_MAX_RESULTS; } });
+Object.defineProperty(exports, "defaultCategoryProvider", { enumerable: true, get: function () { return install_alias_names_js_1.defaultCategoryProvider; } });
+Object.defineProperty(exports, "installAliasNames", { enumerable: true, get: function () { return install_alias_names_js_1.installAliasNames; } });
+Object.defineProperty(exports, "installAliasNamesOnAddressSpace", { enumerable: true, get: function () { return install_alias_names_js_1.installAliasNamesOnAddressSpace; } });
+var last_change_js_1 = require("./last_change.js");
+Object.defineProperty(exports, "LAST_CHANGE_BROWSE_NAME", { enumerable: true, get: function () { return last_change_js_1.LAST_CHANGE_BROWSE_NAME; } });
+Object.defineProperty(exports, "LastChangeTracker", { enumerable: true, get: function () { return last_change_js_1.LastChangeTracker; } });
+var well_known_js_1 = require("./well_known.js");
+Object.defineProperty(exports, "ALIAS_FOR", { enumerable: true, get: function () { return well_known_js_1.ALIAS_FOR; } });
+Object.defineProperty(exports, "ALIAS_NAME_CATEGORY_TYPE", { enumerable: true, get: function () { return well_known_js_1.ALIAS_NAME_CATEGORY_TYPE; } });
+Object.defineProperty(exports, "ALIAS_NAME_TYPE", { enumerable: true, get: function () { return well_known_js_1.ALIAS_NAME_TYPE; } });
+Object.defineProperty(exports, "ALIAS_SERVER_CAPABILITY", { enumerable: true, get: function () { return well_known_js_1.ALIAS_SERVER_CAPABILITY; } });
+Object.defineProperty(exports, "MethodDeclarations", { enumerable: true, get: function () { return well_known_js_1.MethodDeclarations; } });
+Object.defineProperty(exports, "PUBLISHED_DATA_SET_TYPE", { enumerable: true, get: function () { return well_known_js_1.PUBLISHED_DATA_SET_TYPE; } });
+Object.defineProperty(exports, "WellKnownCategories", { enumerable: true, get: function () { return well_known_js_1.WellKnownCategories; } });
+Object.defineProperty(exports, "WellKnownLastChange", { enumerable: true, get: function () { return well_known_js_1.WellKnownLastChange; } });
+Object.defineProperty(exports, "WellKnownOptionalMethods", { enumerable: true, get: function () { return well_known_js_1.WellKnownOptionalMethods; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH,+CAAwG;AAAzE,8GAAA,cAAc,OAAA;AAAE,wGAAA,QAAQ,OAAA;AAAE,yGAAA,SAAS,OAAA;AAAE,2GAAA,WAAW,OAAA;AAC/E,+EAA4G;AAAnG,sIAAA,sBAAsB,OAAA;AAC/B,2DAS8B;AAR1B,+GAAA,SAAS,OAAA;AACT,0HAAA,oBAAoB,OAAA;AACpB,uHAAA,iBAAiB,OAAA;AACjB,+HAAA,yBAAyB,OAAA;AACzB,uHAAA,iBAAiB,OAAA;AACjB,iHAAA,WAAW,OAAA;AACX,yHAAA,mBAAmB,OAAA;AACnB,gIAAA,0BAA0B,OAAA;AAE9B,iEAKiC;AAJ7B,mIAAA,0BAA0B,OAAA;AAE1B,6HAAA,oBAAoB,OAAA;AACpB,8HAAA,qBAAqB,OAAA;AAEzB,mEAWkC;AAT9B,0HAAA,gBAAgB,OAAA;AAEhB,2HAAA,iBAAiB,OAAA;AACjB,kIAAA,wBAAwB,OAAA;AACxB,8HAAA,oBAAoB,OAAA;AACpB,iIAAA,uBAAuB,OAAA;AACvB,gIAAA,sBAAsB,OAAA;AAEtB,6HAAA,mBAAmB,OAAA;AAEvB,2DAK8B;AAF1B,8HAAA,wBAAwB,OAAA;AACxB,0HAAA,oBAAoB,OAAA;AAExB,mEAWkC;AAV9B,oIAAA,0BAA0B,OAAA;AAC1B,kIAAA,wBAAwB,OAAA;AAExB,6HAAA,mBAAmB,OAAA;AACnB,iIAAA,uBAAuB,OAAA;AAIvB,2HAAA,iBAAiB,OAAA;AACjB,yIAAA,+BAA+B,OAAA;AAEnC,mDAI0B;AAHtB,yHAAA,uBAAuB,OAAA;AACvB,mHAAA,iBAAiB,OAAA;AAGrB,iDAUyB;AATrB,0GAAA,SAAS,OAAA;AACT,yHAAA,wBAAwB,OAAA;AACxB,gHAAA,eAAe,OAAA;AACf,wHAAA,uBAAuB,OAAA;AACvB,mHAAA,kBAAkB,OAAA;AAClB,wHAAA,uBAAuB,OAAA;AACvB,oHAAA,mBAAmB,OAAA;AACnB,oHAAA,mBAAmB,OAAA;AACnB,yHAAA,wBAAwB,OAAA"}

package/dist/install_alias_names.d.ts

@@ -0,0 +1,229 @@
+/**
+ * @module node-opcua-alias-name-server
+ *
+ * Install OPC 10000-17 AliasName support on a Server.
+ *
+ * Every node-opcua Server that loads the standard nodeset already exposes
+ * `Aliases`, `TagVariables` and `Topics`, each carrying a MANDATORY `FindAlias`
+ * Method that is bound to nothing. A conformance tester therefore sees the SDK
+ * advertise the AliasName feature and then fail its only required Method. This
+ * binds them.
+ */
+import type { IAddressSpace, ISessionContext, UAObject } from "node-opcua-address-space-base";
+import type { IAliasStore, LikeOptions } from "node-opcua-alias-name-common";
+import type { NodeId } from "node-opcua-nodeid";
+import { type BindAliasCategoryOptions } from "./bind_alias_category.js";
+import type { AliasComparator } from "./bind_find_alias.js";
+import { LastChangeTracker } from "./last_change.js";
+import { DEFAULT_MAX_RESULTS } from "./well_known.js";
+export { DEFAULT_MAX_RESULTS };
+/**
+ * Supplies the `AliasNameCategoryType` instances to bind.
+ *
+ * Defaults to {@link defaultCategoryProvider}, which walks down from `Aliases`.
+ * Replace it when the category set is not a static tree — one category per
+ * customer, one per upstream Server, categories that appear and disappear at
+ * runtime. May be asynchronous, since the set may have to be fetched.
+ *
+ * A provider only decides *what installation binds*. Categories created after
+ * installation are bound with {@link bindAliasCategory}, or created already
+ * bound with {@link addAliasCategory}.
+ */
+export type CategoryProvider = (addressSpace: IAddressSpace) => UAObject[] | Promise<UAObject[]>;
+/**
+ * The default provider: every `AliasNameCategoryType` instance at or below
+ * `Aliases`, plus any roots named in `additionalCategoryRoots`.
+ *
+ * `additionalCategoryRoots` is expressed through this rather than as a parallel
+ * mechanism, so a custom provider can reuse it — `defaultCategoryProvider(roots)`
+ * composes with whatever else the Server knows about.
+ */
+export declare function defaultCategoryProvider(additionalRoots?: Array<NodeId | UAObject>): CategoryProvider;
+export interface InstallAliasNamesOptions {
+    /**
+     * Where aliases come from. Defaults to an {@link AddressSpaceAliasStore},
+     * which reads them straight out of the address space — so a Server whose
+     * NodeSet2.xml already models `AliasNameType` instances needs no options at
+     * all.
+     */
+    store?: IAliasStore;
+    /** Result cap per call (clause 6.3.2 Table 4). Defaults to {@link DEFAULT_MAX_RESULTS}. */
+    maxResults?: number;
+    /**
+     * Also bind `FindAliasVerbose` (clause 6.3.3, conformance unit
+     * AliasName FindAliasVerbose). On by default: it costs one extra Method per
+     * category and is what lets a Client see which category held a hit.
+     */
+    verbose?: boolean;
+    /**
+     * Also expose `AddAliasesToCategory` and `DeleteAliasesFromCategory`
+     * (clauses 6.3.4 and 6.3.5, conformance unit *AliasName Configuration
+     * Support*, CU 5874).
+     *
+     * **Off by default**: both Methods are Optional, and a write surface that
+     * appears without being asked for is a surface nobody reviewed. Turning it
+     * on is not by itself dangerous — every call is denied until
+     * {@link isWriteAllowed} says otherwise — but the Methods do become visible
+     * to a browsing Client.
+     */
+    configurationMethods?: boolean;
+    /** Passed to the `Like` matcher used by the default store. */
+    likeOptions?: LikeOptions;
+    /** Result ordering (clause 6.3.2, "best match first"). */
+    comparator?: AliasComparator;
+    /**
+     * Read gate, consulted **per category** and allowed to be asynchronous.
+     * Defaults to allowing everyone, so a Server that simply publishes its
+     * aliases is unaffected.
+     *
+     * A direct call on a denied category answers `Bad_UserAccessDenied`; a
+     * denied category reached by a recursive search is omitted and the call
+     * still returns `Good`, so nothing reveals that it exists.
+     *
+     * OPC 10000-17 defines no security model — four `Bad_UserAccessDenied` rows,
+     * no Security clause, no Roles, and no `RolePermissions` on any Part 17 node
+     * in the standard nodeset — so every Server has to supply its own rule.
+     */
+    isReadAllowed?: (context: ISessionContext, categoryNodeId: NodeId) => boolean | Promise<boolean>;
+    /**
+     * Write gate for the configuration Methods, mirroring
+     * {@link isReadAllowed}. **Defaults to denying everyone**: the write surface
+     * is the one place where a permissive default would be a security defect
+     * rather than a convenience.
+     */
+    isWriteAllowed?: (context: ISessionContext, categoryNodeId: NodeId) => boolean | Promise<boolean>;
+    /**
+     * File backing the persisted `LastChange` values (clause 6.3.1: *"The
+     * LastChange shall be persisted"*).
+     *
+     * Without it, every restart resets `LastChange` to zero — and a Client that
+     * sees a value older than the one it cached is required by clause 6.3.1 to
+     * clear its cache. So an unpersisted Server silently orders every connected
+     * Client to discard a still-valid cache on every restart. Set this on any
+     * Server that Clients cache against.
+     *
+     * The file is small JSON: a version and a map of category NodeId to
+     * VersionTime. Writes are atomic.
+     */
+    persistencePath?: string;
+    /**
+     * Add a `LastChange` Property to every category, not only the `Aliases` root.
+     *
+     * On by default. `LastChange` is Optional on `AliasNameCategoryType` and the
+     * shipped nodeset instantiates it only on the root, which clause 9.2 makes
+     * mandatory — but the clause 6.3.1 rollup is only observable where the
+     * Property exists, so a Client watching one branch needs it there. Turn it
+     * off to keep the address space exactly as the nodeset ships it.
+     */
+    lastChangeOnAllCategories?: boolean;
+    /**
+     * Supplies "now" as a VersionTime, for tests that need to pin it. A
+     * VersionTime has one-second resolution, which is otherwise awkward to
+     * assert against.
+     */
+    nowVersionTime?: () => number;
+    /**
+     * Extra roots to search for `AliasNameCategoryType` instances.
+     *
+     * Categories are discovered by walking down from `Aliases`, which is where
+     * clause 9.1 puts them. Name a category here if the Server models one
+     * outside that hierarchy, otherwise its MANDATORY `FindAlias` stays unbound.
+     *
+     * Ignored when {@link categoryProvider} is supplied — compose it in with
+     * {@link defaultCategoryProvider} instead of passing both.
+     */
+    additionalCategoryRoots?: Array<NodeId | UAObject>;
+    /**
+     * Replace category discovery entirely. See {@link CategoryProvider}.
+     */
+    categoryProvider?: CategoryProvider;
+    /**
+     * Declare the `ALIAS` ServerCapability (OPC 10000-12 Annex D Table D.1).
+     * **On by default.**
+     *
+     * A Server that does not advertise it is never discovered by anything
+     * looking for alias-capable Servers, and nothing reports the failure — so
+     * leaving it to each caller to remember means it will sometimes be
+     * forgotten, invisibly. Installing the feature and declaring it are the same
+     * decision, so they happen together.
+     *
+     * **Call `installAliasNames` before `server.start()`.** The address space
+     * exists from `initialize()` onwards, and mDNS/LDS registration reads the
+     * capability list during `start()` — afterwards the list is still correct
+     * for anything reading `ServerConfiguration`, but the registration has
+     * already gone out without it.
+     *
+     * Set false if the Server manages its own capability list.
+     */
+    advertiseCapability?: boolean;
+}
+export interface InstallAliasNamesResult {
+    /** The store that was used — the injected one, or the default. */
+    store: IAliasStore;
+    /** Every `AliasNameCategoryType` instance that had its Methods bound. */
+    categories: NodeId[];
+    /** True when this call did the work; false when AliasNames were already installed. */
+    installed: boolean;
+    /**
+     * Keeps `LastChange` correct across the hierarchy, and persists it
+     * (clause 6.3.1).
+     */
+    lastChange?: LastChangeTracker;
+    /**
+     * The options every category was bound with.
+     *
+     * Pass these to {@link bindAliasCategory} to bind a category created later
+     * exactly as the installed ones were bound, without reassembling them by
+     * hand and risking a different store or result cap.
+     */
+    bindingOptions: BindAliasCategoryOptions;
+}
+/** The server-like object we need: the address space, and the capability list. */
+export interface IServerForAliasNames {
+    engine: {
+        addressSpace: IAddressSpace | null;
+    };
+    /**
+     * The Server's OPC 10000-12 Annex D capability identifiers — on an
+     * `OPCUAServer` this is `capabilitiesForMDNS`. Optional so a caller can pass
+     * anything address-space-shaped; when present, `ALIAS` is added to it.
+     */
+    capabilitiesForMDNS?: string[];
+}
+/**
+ * The `ALIAS` ServerCapability identifier (OPC 10000-12 Annex D Table D.1).
+ *
+ * Part 17's prose writes it `Alias`; Part 12 Annex D is the normative source and
+ * writes `ALIAS`, matched case-insensitively.
+ */
+export declare const ALIAS_SERVER_CAPABILITY_ID = "ALIAS";
+/**
+ * Add `ALIAS` to a Server's Annex D capability list, in place.
+ *
+ * Idempotent, case-insensitive, and replaces the `NA` placeholder rather than
+ * producing the meaningless `["NA", "ALIAS"]`.
+ *
+ * @returns true when the list was changed.
+ */
+export declare function advertiseAliasCapability(capabilities: string[]): boolean;
+/**
+ * Install AliasName support on a Server.
+ *
+ * Call it **between `initialize()` and `start()`**: the address space exists
+ * from `initialize()`, and the `ALIAS` capability has to be in place before
+ * `start()` performs the mDNS/LDS registration that reads it.
+ *
+ * ```ts
+ * await server.initialize();
+ * await installAliasNames(server);
+ * await server.start();
+ * ```
+ */
+export declare function installAliasNames(server: IServerForAliasNames, options?: InstallAliasNamesOptions): Promise<InstallAliasNamesResult>;
+/**
+ * Install AliasName support directly on an address space.
+ *
+ * The two-tier form used elsewhere in the SDK: this one needs no Server, so it
+ * can be driven from a test or from a tool that only has an address space.
+ */
+export declare function installAliasNamesOnAddressSpace(addressSpace: IAddressSpace, options?: InstallAliasNamesOptions): Promise<InstallAliasNamesResult>;