@sphereon/ssi-sdk.uni-resolver-registrar-api
Version:
423 lines (419 loc) • 15.8 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
DidWebServer: () => DidWebServer,
UniResolverApiServer: () => UniResolverApiServer,
createDidEndpoint: () => createDidEndpoint,
deactivateDidEndpoint: () => deactivateDidEndpoint,
deleteDidEndpoint: () => deleteDidEndpoint,
didWebDomainEndpoint: () => didWebDomainEndpoint,
getDidMethodsEndpoint: () => getDidMethodsEndpoint,
resolveDidEndpoint: () => resolveDidEndpoint
});
module.exports = __toCommonJS(index_exports);
// src/api-functions.ts
var import_ssi_sdk_ext = require("@sphereon/ssi-sdk-ext.did-utils");
var import_ssi_sdk_ext2 = require("@sphereon/ssi-sdk-ext.key-utils");
var import_ssi_express_support = require("@sphereon/ssi-express-support");
var import_ssi_types = require("@sphereon/ssi-types");
var import_uuid = require("uuid");
var import_debug = __toESM(require("debug"), 1);
var debug = (0, import_debug.default)("sphereon:ssi-sdk:uni-resolver-registrar");
function createDidEndpoint(router, context, opts) {
if (opts?.enabled === false) {
console.log(`create DID endpoint is disabled`);
return;
}
const path = opts?.path ?? "/identifiers";
router.post(path, (0, import_ssi_express_support.checkAuth)(opts?.endpoint), async (request, response) => {
try {
const createRequest = request.body;
if (!createRequest) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "No DID create request present");
}
const did = createRequest.did;
const didMethod = request.query.method ?? (did ? (0, import_ssi_types.parseDid)(did).method : opts?.defaultMethod);
const allDidMethods = await (0, import_ssi_sdk_ext.getAgentDIDMethods)(context);
if (!didMethod) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "No DID method supplied or deductible");
} else if (did && (0, import_ssi_types.parseDid)(did).method != didMethod) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "DID method did not match method param");
} else if (!allDidMethods.includes(didMethod)) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "DID method not supported");
}
const provider = `did:${didMethod}`;
const jobId = createRequest.jobId ?? (0, import_uuid.v4)();
let alias = void 0;
if (didMethod === "web") {
if (!did) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, 'Please provide a value for "did" in the request body when creating a DID web');
}
alias = (0, import_ssi_types.parseDid)(did).id;
if (!alias) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "Could not determine alias from did:web DID value: " + did);
}
}
let identifier;
let state;
if (opts?.noErrorOnExistingDid && did) {
try {
identifier = await context.agent.didManagerGet({
did
});
state = "exists";
} catch (e) {
}
}
if (identifier === void 0) {
if (createRequest.options.storeSecrets === false) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "Only storeSecrets mode is supported currently");
} else if (createRequest.options.storeSecrets || opts?.storeSecrets) {
identifier = await context.agent.didManagerCreate({
provider,
alias,
kms: opts?.kms
});
state = "finished";
} else {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "Only storeSecrets mode is supported currently");
}
}
if (!identifier || !state) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "An identifier and did state should be present at this point");
}
const didDocument = (0, import_ssi_sdk_ext.toDidDocument)(identifier, {
did,
use: [
import_ssi_sdk_ext2.JwkKeyUse.Signature,
import_ssi_sdk_ext2.JwkKeyUse.Encryption
]
});
const createState = {
jobId,
didState: {
did: identifier.did,
state,
didDocument
}
};
response.statusCode = 200;
return response.send(createState);
} catch (e) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 500, e.message, e);
}
});
}
__name(createDidEndpoint, "createDidEndpoint");
function getDidMethodsEndpoint(router, context, opts) {
if (opts?.enabled === false) {
console.log(`Get DID methods endpoint is disabled`);
return;
}
const path = opts?.path ?? "/methods";
router.get(path, (0, import_ssi_express_support.checkAuth)(opts?.endpoint), async (request, response) => {
try {
const methods = await (0, import_ssi_sdk_ext.getAgentDIDMethods)(context);
response.statusCode = 200;
return response.send(methods);
} catch (e) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 500, e.message, e);
}
});
}
__name(getDidMethodsEndpoint, "getDidMethodsEndpoint");
async function agentDidToResolutionResult(context, did) {
try {
const identifier = await context.agent.didManagerGet({
did
});
debug(JSON.stringify(identifier, null, 2));
return (0, import_ssi_sdk_ext.toDidResolutionResult)(identifier, {
did,
supportedMethods: await (0, import_ssi_sdk_ext.getAgentDIDMethods)(context)
});
} catch (error) {
console.log(JSON.stringify(error.message));
return {
didDocument: null,
didResolutionMetadata: {
error: "notFound"
},
didDocumentMetadata: {}
};
}
}
__name(agentDidToResolutionResult, "agentDidToResolutionResult");
function resolveDidEndpoint(router, context, opts) {
if (opts?.enabled === false) {
console.log(`Resolve DID endpoint is disabled`);
return;
}
const path = opts?.path ?? "/identifiers/:identifier";
router.get(path, (0, import_ssi_express_support.checkAuth)(opts?.endpoint), async (request, response) => {
try {
const did = request.params.identifier;
if (!did) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "no identifier provided");
}
const mode = request.query.mode?.toString().toLowerCase() ?? opts?.mode?.toLowerCase() ?? "hybrid";
let resolutionResult;
if (mode === "local" || mode === "hybrid") {
resolutionResult = await agentDidToResolutionResult(context, did);
}
if (mode !== "local" && !resolutionResult?.didDocument) {
resolutionResult = await context.agent.resolveDid({
didUrl: did
});
}
response.statusCode = 200;
return response.send(resolutionResult);
} catch (e) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 500, e.message, e);
}
});
}
__name(resolveDidEndpoint, "resolveDidEndpoint");
function deleteDidEndpoint(router, context, opts) {
if (opts?.enabled === false) {
console.log(`Deactivate DID endpoint is disabled`);
return;
}
router.delete(opts?.path ?? "/identifiers/:identifier", (0, import_ssi_express_support.checkAuth)(opts?.endpoint), async (request, response) => {
try {
const did = request.params.identifier;
if (!did) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "no DID provided");
}
const result = await context.agent.didManagerDelete({
did
});
if (!result) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 404, `id ${did} not found`);
}
response.statusCode = 200;
return response.send();
} catch (e) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 500, e.message, e);
}
});
}
__name(deleteDidEndpoint, "deleteDidEndpoint");
function deactivateDidEndpoint(router, context, opts) {
if (opts?.enabled === false) {
console.log("Deactivate DID endpoint is disabled");
return;
}
router.post(opts?.path ?? "/deactivate", (0, import_ssi_express_support.checkAuth)(opts?.endpoint), async (request, response) => {
try {
const deactivateRequest = request.body;
if (!deactivateRequest) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "Invalid request body", {
state: "failed"
});
}
const { did, jobId = (0, import_uuid.v4)() } = deactivateRequest;
if (!did) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 400, "No DID provided", {
state: "failed"
});
}
const result = await context.agent.didManagerDelete({
did
});
if (!result) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 404, `DID ${did} not found`, {
state: "failed"
});
}
response.status(200).json({
state: "finished",
did,
jobId
});
return response.send();
} catch (e) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 500, e.message, {
state: "failed",
errorDetails: e
});
}
});
}
__name(deactivateDidEndpoint, "deactivateDidEndpoint");
function didWebDomainEndpoint(router, context, opts) {
if (opts?.enabled === false) {
console.log(`DID Web domain resolution endpoint is disabled`);
return;
}
router.get(opts?.path ?? ":path(*)/did.json", (0, import_ssi_express_support.checkAuth)(opts?.endpoint), async (request, response) => {
try {
const path = request.params.path;
if (!path || path.length === 0) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 404, "Not found");
}
let did;
did = `did:web:${opts?.hostname?.replace("https://", "")?.replace("http://", "") ?? request.hostname}`;
if (path !== "/.well-known") {
if (opts?.disableSubPaths) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 404, "Not found");
}
const suffix = path.replace(/\//g, ":").replace(/%2F/g, ":");
if (!suffix.startsWith(":")) {
did += ":";
}
did += suffix;
} else if (opts?.disableWellKnown) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 404, "Not found");
}
const resolutionResult = await agentDidToResolutionResult(context, did);
if (!resolutionResult || !resolutionResult.didDocument || resolutionResult?.didResolutionMetadata?.error === "notFound") {
return (0, import_ssi_express_support.sendErrorResponse)(response, 404, "Not found");
}
response.statusCode = 200;
return response.send(resolutionResult.didDocument);
} catch (e) {
return (0, import_ssi_express_support.sendErrorResponse)(response, 500, e.message, e);
}
});
}
__name(didWebDomainEndpoint, "didWebDomainEndpoint");
// src/uni-resolver-api-server.ts
var import_ssi_sdk = require("@sphereon/ssi-sdk.core");
var import_ssi_express_support2 = require("@sphereon/ssi-express-support");
var import_express = __toESM(require("express"), 1);
var UniResolverApiServer = class {
static {
__name(this, "UniResolverApiServer");
}
get router() {
return this._router;
}
_express;
_agent;
_opts;
_router;
constructor(args) {
const { agent, opts } = args;
this._agent = agent;
(0, import_ssi_express_support2.copyGlobalAuthToEndpoints)({
opts,
keys: [
"getDidMethods",
"createDid",
"resolveDid",
"deactivateDid"
]
});
this._opts = opts;
this._express = args.expressSupport.express;
this._router = import_express.default.Router();
const context = (0, import_ssi_sdk.agentContext)(agent);
const features = opts?.enableFeatures ?? [
"did-resolve",
"did-persist"
];
console.log(`DID Uni Resolver and Registrar API enabled, with features: ${JSON.stringify(features)}}`);
if (features.includes("did-resolve")) {
resolveDidEndpoint(this.router, context, opts?.endpointOpts?.resolveDid);
getDidMethodsEndpoint(this.router, context, opts?.endpointOpts?.getDidMethods);
}
if (features.includes("did-persist")) {
createDidEndpoint(this.router, context, opts?.endpointOpts?.createDid);
deleteDidEndpoint(this.router, context, opts?.endpointOpts?.deactivateDid);
deactivateDidEndpoint(this.router, context, opts?.endpointOpts?.deactivateDid);
}
this._express.use(opts?.endpointOpts?.basePath ?? "", this.router);
}
get agent() {
return this._agent;
}
get opts() {
return this._opts;
}
get express() {
return this._express;
}
};
// src/did-web-server.ts
var import_ssi_sdk2 = require("@sphereon/ssi-sdk.core");
var import_express2 = __toESM(require("express"), 1);
var DidWebServer = class {
static {
__name(this, "DidWebServer");
}
get router() {
return this._router;
}
_express;
_agent;
_opts;
_router;
constructor(args) {
const { agent, opts } = args;
const features = opts?.enableFeatures ?? [];
if (!features.includes("did-web-global-resolution")) {
console.log("did:web hosting service NOT enabled");
return;
}
this._agent = agent;
if (opts?.globalAuth) {
copyGlobalAuthToEndpoint(opts, "endpointOpts");
}
this._opts = opts;
this._express = args.expressSupport.express;
this._router = import_express2.default.Router();
const context = (0, import_ssi_sdk2.agentContext)(agent);
console.log(`did:web hosting service enabled`);
didWebDomainEndpoint(this.router, context, opts?.endpointOpts);
this._express.use(this.router);
}
get agent() {
return this._agent;
}
get opts() {
return this._opts;
}
get express() {
return this._express;
}
};
function copyGlobalAuthToEndpoint(opts, key) {
if (opts?.globalAuth) {
opts[key] = {
...opts?.globalAuth,
// @ts-ignore
...opts[key]
};
}
}
__name(copyGlobalAuthToEndpoint, "copyGlobalAuthToEndpoint");
//# sourceMappingURL=index.cjs.map