@azure/communication-common/dist/commonjs/identifierModelSerializer.js

Common package for Azure Communication services.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var identifierModelSerializer_exports = {};
__export(identifierModelSerializer_exports, {
  deserializeCommunicationIdentifier: () => deserializeCommunicationIdentifier,
  serializeCommunicationIdentifier: () => serializeCommunicationIdentifier
});
module.exports = __toCommonJS(identifierModelSerializer_exports);
var import_identifierModels = require("./identifierModels.js");
const assertNotNullOrUndefined = (obj, prop) => {
  const subObjName = Object.keys(obj)[0];
  const subObj = obj[subObjName];
  if (prop in subObj) {
    return subObj[prop];
  }
  throw new Error(`Property ${prop} is required for identifier of type ${subObjName}.`);
};
const assertMaximumOneNestedModel = (identifier) => {
  const presentProperties = [];
  if (identifier.communicationUser !== void 0) {
    presentProperties.push("communicationUser");
  }
  if (identifier.microsoftTeamsUser !== void 0) {
    presentProperties.push("microsoftTeamsUser");
  }
  if (identifier.microsoftTeamsApp !== void 0) {
    presentProperties.push("microsoftTeamsApp");
  }
  if (identifier.phoneNumber !== void 0) {
    presentProperties.push("phoneNumber");
  }
  if (identifier.teamsExtensionUser !== void 0) {
    presentProperties.push("teamsExtensionUser");
  }
  if (presentProperties.length > 1) {
    throw new Error(
      `Only one of the properties in ${JSON.stringify(presentProperties)} should be present.`
    );
  }
};
const serializeCommunicationIdentifier = (identifier) => {
  const identifierKind = (0, import_identifierModels.getIdentifierKind)(identifier);
  switch (identifierKind.kind) {
    case "communicationUser":
      return {
        rawId: (0, import_identifierModels.getIdentifierRawId)(identifierKind),
        communicationUser: { id: identifierKind.communicationUserId }
      };
    case "phoneNumber":
      return {
        rawId: identifierKind.rawId ?? (0, import_identifierModels.getIdentifierRawId)(identifierKind),
        phoneNumber: {
          value: identifierKind.phoneNumber,
          isAnonymous: identifierKind.isAnonymous ?? false,
          assertedId: identifierKind.assertedId
        }
      };
    case "microsoftTeamsUser":
      return {
        rawId: identifierKind.rawId ?? (0, import_identifierModels.getIdentifierRawId)(identifierKind),
        microsoftTeamsUser: {
          userId: identifierKind.microsoftTeamsUserId,
          isAnonymous: identifierKind.isAnonymous ?? false,
          cloud: identifierKind.cloud ?? "public"
        }
      };
    case "microsoftTeamsApp":
      return {
        rawId: identifierKind.rawId ?? (0, import_identifierModels.getIdentifierRawId)(identifierKind),
        microsoftTeamsApp: {
          appId: identifierKind.teamsAppId,
          cloud: identifierKind.cloud ?? "public"
        }
      };
    case "teamsExtensionUser":
      return {
        rawId: identifierKind.rawId ?? (0, import_identifierModels.getIdentifierRawId)(identifierKind),
        teamsExtensionUser: {
          userId: identifierKind.userId,
          tenantId: identifierKind.tenantId,
          resourceId: identifierKind.resourceId,
          cloud: identifierKind.cloud ?? "public"
        }
      };
    case "unknown":
      return { rawId: identifierKind.id };
    default:
      throw new Error(`Can't serialize an identifier with kind ${identifierKind.kind}`);
  }
};
const getKind = (serializedIdentifier) => {
  if (serializedIdentifier.communicationUser) {
    return "communicationUser";
  }
  if (serializedIdentifier.phoneNumber) {
    return "phoneNumber";
  }
  if (serializedIdentifier.microsoftTeamsUser) {
    return "microsoftTeamsUser";
  }
  if (serializedIdentifier.microsoftTeamsApp) {
    return "microsoftTeamsApp";
  }
  if (serializedIdentifier.teamsExtensionUser) {
    return "teamsExtensionUser";
  }
  return "unknown";
};
const deserializeCommunicationIdentifier = (serializedIdentifier) => {
  assertMaximumOneNestedModel(serializedIdentifier);
  const communicationUser = serializedIdentifier.communicationUser;
  const microsoftTeamsUser = serializedIdentifier.microsoftTeamsUser;
  const microsoftTeamsApp = serializedIdentifier.microsoftTeamsApp;
  const phoneNumber = serializedIdentifier.phoneNumber;
  const teamsExtensionUser = serializedIdentifier.teamsExtensionUser;
  const kind = serializedIdentifier.kind ?? getKind(serializedIdentifier);
  if (kind === "communicationUser" && communicationUser) {
    return {
      kind: "communicationUser",
      communicationUserId: assertNotNullOrUndefined({ communicationUser }, "id")
    };
  }
  if (kind === "phoneNumber" && phoneNumber) {
    return {
      kind: "phoneNumber",
      phoneNumber: assertNotNullOrUndefined({ phoneNumber }, "value"),
      rawId: assertNotNullOrUndefined({ phoneNumber: serializedIdentifier }, "rawId"),
      isAnonymous: phoneNumber.isAnonymous ?? false,
      assertedId: phoneNumber.assertedId
    };
  }
  if (kind === "microsoftTeamsUser" && microsoftTeamsUser) {
    return {
      kind: "microsoftTeamsUser",
      microsoftTeamsUserId: assertNotNullOrUndefined({ microsoftTeamsUser }, "userId"),
      isAnonymous: assertNotNullOrUndefined({ microsoftTeamsUser }, "isAnonymous"),
      cloud: assertNotNullOrUndefined({ microsoftTeamsUser }, "cloud"),
      rawId: assertNotNullOrUndefined({ microsoftTeamsUser: serializedIdentifier }, "rawId")
    };
  }
  if (kind === "microsoftTeamsApp" && microsoftTeamsApp) {
    return {
      kind: "microsoftTeamsApp",
      teamsAppId: assertNotNullOrUndefined({ microsoftTeamsApp }, "appId"),
      cloud: assertNotNullOrUndefined({ microsoftTeamsApp }, "cloud"),
      rawId: assertNotNullOrUndefined({ microsoftTeamsApp: serializedIdentifier }, "rawId")
    };
  }
  if (kind === "teamsExtensionUser" && teamsExtensionUser) {
    return {
      kind: "teamsExtensionUser",
      userId: assertNotNullOrUndefined({ teamsExtensionUser }, "userId"),
      tenantId: assertNotNullOrUndefined({ teamsExtensionUser }, "tenantId"),
      resourceId: assertNotNullOrUndefined({ teamsExtensionUser }, "resourceId"),
      cloud: assertNotNullOrUndefined({ teamsExtensionUser }, "cloud"),
      rawId: assertNotNullOrUndefined({ teamsExtensionUser: serializedIdentifier }, "rawId")
    };
  }
  return {
    kind: "unknown",
    id: assertNotNullOrUndefined({ unknown: serializedIdentifier }, "rawId")
  };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  deserializeCommunicationIdentifier,
  serializeCommunicationIdentifier
});
//# sourceMappingURL=identifierModelSerializer.js.map