@twin.org/identity-rest-client 0.0.2-next.9 → 0.0.3-next.10

package/dist/cjs/index.cjs

@@ -1,469 +0,0 @@
-'use strict';
-
-var apiCore = require('@twin.org/api-core');
-var core = require('@twin.org/core');
-var identityModels = require('@twin.org/identity-models');
-var standardsW3cDid = require('@twin.org/standards-w3c-did');
-var apiModels = require('@twin.org/api-models');
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Client for performing identity through to REST endpoints.
- */
-class IdentityRestClient extends apiCore.BaseRestClient {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "IdentityRestClient";
-    /**
-     * Create a new instance of IdentityClient.
-     * @param config The configuration for the client.
-     */
-    constructor(config) {
-        super("IdentityRestClient", config, "identity");
-    }
-    /**
-     * Create a new identity.
-     * @param namespace The namespace of the connector to use for the identity, defaults to service configured namespace.
-     * @returns The created identity document.
-     */
-    async identityCreate(namespace) {
-        const response = await this.fetch("/", "POST", {
-            body: {
-                namespace
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Remove an identity.
-     * @param identity The id of the document to remove.
-     * @returns Nothing.
-     */
-    async identityRemove(identity) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "identity", identity);
-        await this.fetch("/:identity", "DELETE", {
-            pathParams: {
-                identity
-            }
-        });
-    }
-    /**
-     * Add a verification method to the document in JSON Web key Format.
-     * @param identity The id of the document to add the verification method to.
-     * @param verificationMethodType The type of the verification method to add.
-     * @param verificationMethodId The id of the verification method, if undefined uses the kid of the generated JWK.
-     * @returns The verification method.
-     * @throws NotFoundError if the id can not be resolved.
-     * @throws NotSupportedError if the platform does not support multiple keys.
-     */
-    async verificationMethodCreate(identity, verificationMethodType, verificationMethodId) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "identity", identity);
-        core.Guards.arrayOneOf(IdentityRestClient.CLASS_NAME, "verificationMethodType", verificationMethodType, Object.values(standardsW3cDid.DidVerificationMethodType));
-        const response = await this.fetch("/:identity/verification-method", "POST", {
-            pathParams: {
-                identity
-            },
-            body: {
-                verificationMethodType,
-                verificationMethodId
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Remove a verification method from the document.
-     * @param verificationMethodId The id of the verification method.
-     * @returns Nothing.
-     * @throws NotFoundError if the id can not be resolved.
-     * @throws NotSupportedError if the platform does not support multiple revocable keys.
-     */
-    async verificationMethodRemove(verificationMethodId) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-        await this.fetch("/:identity/verification-method/:verificationMethodId", "DELETE", {
-            pathParams: {
-                identity: idParts.id,
-                verificationMethodId: idParts.fragment ?? ""
-            }
-        });
-    }
-    /**
-     * Add a service to the document.
-     * @param identity The id of the document to add the service to.
-     * @param serviceId The id of the service.
-     * @param serviceType The type of the service.
-     * @param serviceEndpoint The endpoint for the service.
-     * @returns The service.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async serviceCreate(identity, serviceId, serviceType, serviceEndpoint) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "identity", identity);
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "serviceId", serviceId);
-        if (core.Is.array(serviceType)) {
-            core.Guards.arrayValue(IdentityRestClient.CLASS_NAME, "serviceType", serviceType);
-        }
-        else {
-            core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "serviceType", serviceType);
-        }
-        if (core.Is.array(serviceEndpoint)) {
-            core.Guards.arrayValue(IdentityRestClient.CLASS_NAME, "serviceEndpoint", serviceEndpoint);
-        }
-        else {
-            core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "serviceEndpoint", serviceEndpoint);
-        }
-        const response = await this.fetch("/:identity/service", "POST", {
-            pathParams: {
-                identity
-            },
-            body: {
-                serviceId,
-                type: serviceType,
-                endpoint: serviceEndpoint
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Remove a service from the document.
-     * @param serviceId The id of the service.
-     * @returns Nothing.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async serviceRemove(serviceId) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "serviceId", serviceId);
-        const idParts = identityModels.DocumentHelper.parseId(serviceId);
-        await this.fetch("/:identity/service/:serviceId", "DELETE", {
-            pathParams: {
-                identity: idParts.id,
-                serviceId: idParts.fragment ?? ""
-            }
-        });
-    }
-    /**
-     * Create a verifiable credential for a verification method.
-     * @param verificationMethodId The verification method id to use.
-     * @param id The id of the credential.
-     * @param subject The credential subject to store in the verifiable credential.
-     * @param options Additional options for creating the verifiable credential.
-     * @param options.revocationIndex The bitmap revocation index of the credential, if undefined will not have revocation status.
-     * @param options.expirationDate The date the verifiable credential is valid until.
-     * @returns The created verifiable credential and its token.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async verifiableCredentialCreate(verificationMethodId, id, subject, options) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        core.Guards.object(IdentityRestClient.CLASS_NAME, "subject", subject);
-        if (!core.Is.undefined(options?.revocationIndex)) {
-            core.Guards.number(IdentityRestClient.CLASS_NAME, "options.revocationIndex", options?.revocationIndex);
-        }
-        const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-        const response = await this.fetch("/:identity/verifiable-credential", "POST", {
-            pathParams: {
-                identity: idParts.id,
-                verificationMethodId: idParts.fragment ?? ""
-            },
-            body: {
-                credentialId: id,
-                subject,
-                revocationIndex: options?.revocationIndex,
-                expirationDate: options?.expirationDate?.toISOString()
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Verify a verifiable credential is valid.
-     * @param credentialJwt The credential to verify.
-     * @returns The credential stored in the jwt and the revocation status.
-     */
-    async verifiableCredentialVerify(credentialJwt) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "credentialJwt", credentialJwt);
-        const response = await this.fetch("/verifiable-credential/verify", "POST", {
-            query: {
-                jwt: credentialJwt
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Revoke verifiable credential.
-     * @param issuerId The id of the document to update the revocation list for.
-     * @param credentialIndex The revocation bitmap index revoke.
-     * @returns Nothing.
-     */
-    async verifiableCredentialRevoke(issuerId, credentialIndex) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "issuerId", issuerId);
-        core.Guards.integer(IdentityRestClient.CLASS_NAME, "credentialIndex", credentialIndex);
-        await this.fetch("/:identity/verifiable-credential/revoke/:revocationIndex", "GET", {
-            pathParams: {
-                identity: issuerId,
-                revocationIndex: credentialIndex
-            }
-        });
-    }
-    /**
-     * Unrevoke verifiable credential.
-     * @param issuerId The id of the document to update the revocation list for.
-     * @param credentialIndex The revocation bitmap index to un revoke.
-     * @returns Nothing.
-     */
-    async verifiableCredentialUnrevoke(issuerId, credentialIndex) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "issuerId", issuerId);
-        core.Guards.integer(IdentityRestClient.CLASS_NAME, "credentialIndex", credentialIndex);
-        await this.fetch("/:identity/verifiable-credential/unrevoke/:revocationIndex", "GET", {
-            pathParams: {
-                identity: issuerId,
-                revocationIndex: credentialIndex
-            }
-        });
-    }
-    /**
-     * Create a verifiable presentation from the supplied verifiable credentials.
-     * @param verificationMethodId The method to associate with the presentation.
-     * @param presentationId The id of the presentation.
-     * @param contexts The contexts for the data stored in the verifiable credential.
-     * @param types The types for the data stored in the verifiable credential.
-     * @param verifiableCredentials The credentials to use for creating the presentation in jwt format.
-     * @param expiresInMinutes The time in minutes for the presentation to expire.
-     * @returns The created verifiable presentation and its token.
-     * @throws NotFoundError if the id can not be resolved.
-     */
-    async verifiablePresentationCreate(verificationMethodId, presentationId, contexts, types, verifiableCredentials, expiresInMinutes) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        if (core.Is.array(types)) {
-            core.Guards.arrayValue(IdentityRestClient.CLASS_NAME, "types", types);
-        }
-        else if (core.Is.string(types)) {
-            core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "types", types);
-        }
-        core.Guards.arrayValue(IdentityRestClient.CLASS_NAME, "verifiableCredentials", verifiableCredentials);
-        if (!core.Is.undefined(expiresInMinutes)) {
-            core.Guards.integer(IdentityRestClient.CLASS_NAME, "expiresInMinutes", expiresInMinutes);
-        }
-        const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-        const response = await this.fetch("/:identity/verifiable-presentation", "POST", {
-            pathParams: {
-                identity: idParts.id,
-                verificationMethodId: idParts.fragment ?? ""
-            },
-            body: {
-                presentationId,
-                contexts,
-                types,
-                verifiableCredentials,
-                expiresInMinutes
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Verify a verifiable presentation is valid.
-     * @param presentationJwt The presentation to verify.
-     * @returns The presentation stored in the jwt and the revocation status.
-     */
-    async verifiablePresentationVerify(presentationJwt) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "presentationJwt", presentationJwt);
-        const response = await this.fetch("/verifiable-presentation/verify", "POST", {
-            query: {
-                jwt: presentationJwt
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Create a proof for a document with the specified verification method.
-     * @param verificationMethodId The verification method id to use.
-     * @param proofType The type of proof to create.
-     * @param unsecureDocument The unsecure document to create the proof for.
-     * @returns The proof.
-     */
-    async proofCreate(verificationMethodId, proofType, unsecureDocument) {
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "verificationMethodId", verificationMethodId);
-        core.Guards.arrayOneOf(IdentityRestClient.CLASS_NAME, "proofType", proofType, Object.values(standardsW3cDid.ProofTypes));
-        core.Guards.object(IdentityRestClient.CLASS_NAME, "unsecureDocument", unsecureDocument);
-        const idParts = identityModels.DocumentHelper.parseId(verificationMethodId);
-        const response = await this.fetch("/:identity/proof", "POST", {
-            pathParams: {
-                identity: idParts.id,
-                verificationMethodId: idParts.fragment ?? ""
-            },
-            body: {
-                document: unsecureDocument,
-                proofType
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Verify proof for a document with the specified verification method.
-     * @param document The document to verify.
-     * @param proof The proof to verify.
-     * @returns True if the proof is verified.
-     */
-    async proofVerify(document, proof) {
-        core.Guards.object(IdentityRestClient.CLASS_NAME, "document", document);
-        core.Guards.object(IdentityRestClient.CLASS_NAME, "proof", proof);
-        core.Guards.stringValue(IdentityRestClient.CLASS_NAME, "proof.verificationMethod", proof.verificationMethod);
-        const response = await this.fetch("/proof/verify", "POST", {
-            body: {
-                document,
-                proof
-            }
-        });
-        return response.body.verified;
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Client for performing identity through to REST endpoints.
- */
-class IdentityProfileRestClient extends apiCore.BaseRestClient {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "IdentityProfileRestClient";
-    /**
-     * Create a new instance of IdentityClient.
-     * @param config The configuration for the client.
-     */
-    constructor(config) {
-        super("IdentityProfileRestClient", config, "identity/profile");
-    }
-    /**
-     * Create the profile properties for an identity.
-     * @param publicProfile The public profile data as JSON-LD.
-     * @param privateProfile The private profile data as JSON-LD.
-     * @returns Nothing.
-     */
-    async create(publicProfile, privateProfile) {
-        await this.fetch("", "POST", {
-            body: {
-                publicProfile,
-                privateProfile
-            }
-        });
-    }
-    /**
-     * Get the profile properties for an identity.
-     * @param publicPropertyNames The public properties to get for the profile, defaults to all.
-     * @param privatePropertyNames The private properties to get for the profile, defaults to all.
-     * @returns The identity and the items properties.
-     */
-    async get(publicPropertyNames, privatePropertyNames) {
-        const response = await this.fetch("/", "GET", {
-            query: {
-                publicPropertyNames: apiModels.HttpParameterHelper.arrayToString(publicPropertyNames),
-                privatePropertyNames: apiModels.HttpParameterHelper.arrayToString(privatePropertyNames)
-            }
-        });
-        return {
-            identity: response.body.identity,
-            publicProfile: response.body.publicProfile,
-            privateProfile: response.body.privateProfile
-        };
-    }
-    /**
-     * Get the public profile properties for an identity.
-     * @param identity The identity to perform the profile operation on.
-     * @param propertyNames The public properties to get for the profile, defaults to all.
-     * @returns The items properties.
-     */
-    async getPublic(identity, propertyNames) {
-        core.Guards.string(IdentityProfileRestClient.CLASS_NAME, "identity", identity);
-        const response = await this.fetch("/:identity/public", "GET", {
-            pathParams: {
-                identity
-            },
-            query: {
-                propertyNames: apiModels.HttpParameterHelper.arrayToString(propertyNames)
-            }
-        });
-        return response.body;
-    }
-    /**
-     * Update the profile properties of an identity.
-     * @param publicProfile The public profile data as JSON-LD.
-     * @param privateProfile The private profile data as JSON-LD.
-     * @returns Nothing.
-     */
-    async update(publicProfile, privateProfile) {
-        await this.fetch("/", "PUT", {
-            body: {
-                publicProfile,
-                privateProfile
-            }
-        });
-    }
-    /**
-     * Delete the profile for an identity.
-     * @returns Nothing.
-     */
-    async remove() {
-        await this.fetch("/", "DELETE");
-    }
-    /**
-     * Get a list of the requested identities.
-     * @param publicFilters The filters to apply to the identities public profiles.
-     * @param publicPropertyNames The public properties to get for the profile, defaults to all.
-     * @param cursor The cursor for paged requests.
-     * @param limit The maximum number of items in a page.
-     * @returns The list of items and cursor for paging.
-     */
-    async list(publicFilters, publicPropertyNames, cursor, limit) {
-        const response = await this.fetch("/query", "GET", {
-            query: {
-                publicFilters: apiModels.HttpParameterHelper.arrayToString(
-                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                publicFilters?.map(f => `${f.propertyName}:${f.propertyValue}`)),
-                publicPropertyNames: apiModels.HttpParameterHelper.arrayToString(publicPropertyNames),
-                cursor,
-                limit: core.Coerce.string(limit)
-            }
-        });
-        return {
-            items: response.body.items,
-            cursor: response.body.cursor
-        };
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Client for performing identity through to REST endpoints.
- */
-class IdentityResolverRestClient extends apiCore.BaseRestClient {
-    /**
-     * Runtime name for the class.
-     */
-    static CLASS_NAME = "IdentityResolverRestClient";
-    /**
-     * Create a new instance of IdentityClient.
-     * @param config The configuration for the client.
-     */
-    constructor(config) {
-        super("IdentityResolverRestClient", config, "identity");
-    }
-    /**
-     * Resolve an identity.
-     * @param documentId The id of the document to resolve.
-     * @returns The resolved document.
-     */
-    async identityResolve(documentId) {
-        core.Urn.guard(IdentityResolverRestClient.CLASS_NAME, "documentId", documentId);
-        const response = await this.fetch("/:identity", "GET", {
-            pathParams: {
-                identity: documentId
-            }
-        });
-        return response.body;
-    }
-}
-
-exports.IdentityProfileRestClient = IdentityProfileRestClient;
-exports.IdentityResolverRestClient = IdentityResolverRestClient;
-exports.IdentityRestClient = IdentityRestClient;