@c-rex/services 0.1.19 → 0.1.20

package/dist/vcard/index.mjs

@@ -0,0 +1,522 @@
+// src/vcard/profile-utils.ts
+import { CrexSDK } from "@c-rex/core/sdk";
+import { UI_LANG_KEY } from "@c-rex/constants";
+import { cookies } from "next/headers";
+var DEFAULT_LOGO_SRC = "/img/logo.png";
+var normalizePathLikeImageSource = (value) => {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("data:") || trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return `/${trimmed}`;
+};
+var resolveLogoSource = (images = []) => {
+  const sourceFirst = images.map((image) => normalizePathLikeImageSource(image.source)).find((value) => Boolean(value));
+  if (!sourceFirst) {
+    console.warn("[VCardProfile] No usable VCARD image source found. Ignoring 'value' until IDS provides absolute resource URLs.");
+  }
+  return sourceFirst;
+};
+var normalizeHref = (value) => {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://") || trimmed.startsWith("mailto:") || trimmed.startsWith("tel:")) {
+    return trimmed;
+  }
+  return `https://${trimmed}`;
+};
+var SOCIAL_MEDIA_TYPE_URI = "https://www.c-rex.net/ns/iirds/vcard#SocialMedia";
+var SOCIAL_MEDIA_TYPE_URI_NORMALIZED = SOCIAL_MEDIA_TYPE_URI.toLowerCase();
+var isSocialMediaType = (value) => {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === SOCIAL_MEDIA_TYPE_URI_NORMALIZED || normalized.endsWith("#socialmedia");
+};
+var isSocialMediaUrlEntry = (url) => {
+  const hasTypedMarker = Array.isArray(url.types) && url.types.some((type) => isSocialMediaType(type));
+  if (hasTypedMarker) return true;
+  const hasClassMarker = Array.isArray(url.classes) && url.classes.some((cls) => isSocialMediaType(cls?.id));
+  if (hasClassMarker) return true;
+  const hasClassLabelMarker = Array.isArray(url.classes) && url.classes.some(
+    (cls) => (cls?.labels || []).some((label) => (label.value || "").trim().toLowerCase() === "social media")
+  );
+  return hasClassLabelMarker;
+};
+var SOCIAL_PROVIDER_BY_HOST = [
+  { hostPattern: /(^|\.)x\.com$/i, label: "X" },
+  { hostPattern: /(^|\.)twitter\.com$/i, label: "Twitter" },
+  { hostPattern: /(^|\.)facebook\.com$/i, label: "Facebook" },
+  { hostPattern: /(^|\.)instagram\.com$/i, label: "Instagram" },
+  { hostPattern: /(^|\.)youtube\.com$/i, label: "YouTube" },
+  { hostPattern: /(^|\.)youtu\.be$/i, label: "YouTube" },
+  { hostPattern: /(^|\.)linkedin\.com$/i, label: "LinkedIn" },
+  { hostPattern: /(^|\.)xing\.com$/i, label: "Xing" }
+];
+var resolveSocialProviderLabel = (href) => {
+  try {
+    const hostname = new URL(href).hostname.toLowerCase();
+    const provider = SOCIAL_PROVIDER_BY_HOST.find((entry) => entry.hostPattern.test(hostname));
+    return provider?.label || hostname.replace(/^www\./i, "");
+  } catch {
+    return "Social";
+  }
+};
+var isKnownSocialProviderHref = (href) => {
+  try {
+    const hostname = new URL(href).hostname.toLowerCase();
+    return SOCIAL_PROVIDER_BY_HOST.some((entry) => entry.hostPattern.test(hostname));
+  } catch {
+    return false;
+  }
+};
+var resolveTypedSocialLinks = (urls = []) => {
+  const items = urls.filter((url) => {
+    if (isSocialMediaUrlEntry(url)) return true;
+    const href = normalizeHref(url.value);
+    return Boolean(href && isKnownSocialProviderHref(href));
+  }).map((url) => normalizeHref(url.value)).filter((value) => Boolean(value));
+  const byHref = /* @__PURE__ */ new Map();
+  items.forEach((href) => {
+    if (byHref.has(href)) return;
+    const label = resolveSocialProviderLabel(href);
+    byHref.set(href, {
+      href,
+      label,
+      provider: label
+    });
+  });
+  return Array.from(byHref.values());
+};
+var normalizePhone = (value) => {
+  if (!value) return void 0;
+  return value.replace(/^tel:/i, "").trim() || void 0;
+};
+var isDialablePhone = (value) => {
+  if (!value) return false;
+  const normalized = value.trim();
+  if (!normalized) return false;
+  if (!/\d/.test(normalized)) return false;
+  return /^[+\d()[\]\-./\s]+$/.test(normalized);
+};
+var normalizePhoneHref = (value) => {
+  if (!value) return void 0;
+  const normalizedPhone = normalizePhone(value);
+  if (!normalizedPhone || !isDialablePhone(normalizedPhone)) return void 0;
+  return `tel:${normalizedPhone}`;
+};
+var normalizeEmail = (value) => {
+  if (!value) return void 0;
+  return value.replace(/^mailto:/i, "").trim() || void 0;
+};
+var normalizeLanguage = (value) => {
+  return (value || "").trim().toLowerCase().replace("_", "-");
+};
+var getLiteralLanguage = (literal) => {
+  const language = literal.language || literal["xml:lang"] || "";
+  return normalizeLanguage(language);
+};
+var getLocalizedLiteral = (labels = [], uiLanguage) => {
+  const normalizedUiLanguage = normalizeLanguage(uiLanguage);
+  const normalizedUiBaseLanguage = normalizedUiLanguage.split("-")[0];
+  const exact = labels.find((item) => getLiteralLanguage(item) === normalizedUiLanguage)?.value?.trim();
+  if (exact) return exact;
+  const base = labels.find((item) => getLiteralLanguage(item).startsWith(`${normalizedUiBaseLanguage}`))?.value?.trim();
+  if (base) return base;
+  const fallback = labels.find((item) => (item.value || "").trim().length > 0)?.value?.trim();
+  return fallback || void 0;
+};
+var buildTelephoneEntries = (telephones = [], uiLanguage) => {
+  return telephones.reduce((entries, telephone) => {
+    const normalizedValue = normalizePhone(telephone.value);
+    if (!normalizedValue) return entries;
+    const classLabels = (telephone.classes || []).map((cls) => getLocalizedLiteral(cls.labels || [], uiLanguage)).filter((value) => Boolean(value));
+    const dedupedClassLabels = Array.from(
+      new Map(classLabels.map((value) => [value.toLowerCase(), value])).values()
+    );
+    entries.push({
+      label: dedupedClassLabels.length > 0 ? dedupedClassLabels.join(" ") : "",
+      value: normalizedValue,
+      href: normalizePhoneHref(telephone.value)
+    });
+    return entries;
+  }, []);
+};
+var resolveUiLanguage = () => {
+  const sdk = new CrexSDK();
+  const clientConfig = sdk.getClientConfig();
+  const defaultLanguage = normalizeLanguage(clientConfig.languageSwitcher.default || "en-us");
+  const uiLanguageFromCookie = cookies().get(UI_LANG_KEY)?.value;
+  return normalizeLanguage(uiLanguageFromCookie) || defaultLanguage;
+};
+var buildAddressLines = (address) => {
+  if (!address) return [];
+  const line1 = [address.streetAddress].filter(Boolean).join(" ").trim();
+  const line2 = [address.postalCode, address.locality].filter(Boolean).join(" ").trim();
+  const line3 = [address.countryName].filter(Boolean).join(" ").trim();
+  return [line1, line2, line3].filter((line) => line.length > 0);
+};
+var mapVCardEntityToBaseProfile = (entity, options) => {
+  const preferredAddress = entity.addresses?.[0];
+  const preferredEmail = entity.emails?.[0];
+  const preferredWebsite = entity.urls?.find((item) => normalizeHref(item.value));
+  const logoSrc = resolveLogoSource([...entity.logos || [], ...entity.photos || []]) || (options.logoFallbackSrc || DEFAULT_LOGO_SRC);
+  return {
+    id: entity.id || void 0,
+    displayName: entity.organizationName?.trim() || entity.fullName?.trim() || options.displayNameFallback,
+    logoSrc,
+    addressLines: buildAddressLines(preferredAddress),
+    email: normalizeEmail(preferredEmail?.value),
+    telephoneEntries: buildTelephoneEntries(entity.telephones || [], options.uiLanguage),
+    website: normalizeHref(preferredWebsite?.value)
+  };
+};
+var decodeEncodedVcardId = (encodedId) => {
+  try {
+    return decodeURIComponent(encodedId);
+  } catch (error) {
+    console.error(`[VCardProfile] Invalid encoded VCARD ID value: "${encodedId}".`, error);
+    return void 0;
+  }
+};
+var getServerConfig = () => {
+  const sdk = new CrexSDK();
+  return sdk.getServerConfig();
+};
+
+// src/vcard/organization-profile.ts
+import {
+  CREX_API_CACHE_TAG,
+  CREX_API_CACHE_VCARD_TAG,
+  CREX_READMODEL_CACHE_ORGANIZATION_TAG,
+  CREX_READMODEL_CACHE_TAG,
+  CREX_READMODEL_CACHE_VCARD_TAG
+} from "@c-rex/core/requests";
+import { unstable_cache } from "next/cache";
+
+// src/base-server-request.ts
+import { CrexApi } from "@c-rex/core/requests";
+
+// src/server-request-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestContextStorage = new AsyncLocalStorage();
+var withServerRequestContext = async (context, run) => {
+  return requestContextStorage.run(context, run);
+};
+var getServerRequestContext = () => {
+  return requestContextStorage.getStore();
+};
+
+// src/base-server-request.ts
+var baseServerRequest = async (endpoint, query) => {
+  const api = new CrexApi();
+  const requestContext = getServerRequestContext();
+  const response = await api.execute({
+    url: endpoint,
+    method: "GET",
+    params: query,
+    skipCookieTokenLookup: requestContext?.skipCookieTokenLookup,
+    authToken: requestContext?.authToken
+  });
+  return response;
+};
+
+// src/generated/server-requests.ts
+var individualsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Individuals", query);
+};
+var individualsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Individuals/${encodeURIComponent(String(params.id))}`, query);
+};
+var organizationsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/Organizations", query);
+};
+var organizationsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/Organizations/${encodeURIComponent(String(params.id))}`, query);
+};
+var vCardsGetAllServer = async (query) => {
+  return baseServerRequest("vcard/v1/VCards", query);
+};
+var vCardsGetByIdServer = async (params, query) => {
+  return baseServerRequest(`vcard/v1/VCards/${encodeURIComponent(String(params.id))}`, query);
+};
+
+// src/read-models/cache-policy.ts
+var readPositiveInt = (rawValue, fallback) => {
+  const parsed = Number(rawValue);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.floor(parsed);
+};
+var READMODEL_CACHE_POLICY = {
+  metadataRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_METADATA_SECONDS,
+    2 * 60 * 60
+  ),
+  vcardRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_VCARD_SECONDS,
+    6 * 60 * 60
+  ),
+  requestsRevalidateSeconds: readPositiveInt(
+    process.env.CREX_CACHE_REVALIDATE_REQUESTS_SECONDS,
+    15 * 60
+  )
+};
+
+// src/vcard/organization-profile.ts
+var toOrganizationProfile = (organization, options) => {
+  const base = mapVCardEntityToBaseProfile(organization, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    organizationName: base.displayName,
+    socialLinks: resolveTypedSocialLinks(organization.urls || []).map((item) => ({
+      label: item.label,
+      href: item.href
+    }))
+  };
+};
+var ORGANIZATION_PROFILE_REQUIRED_FIELDS = [
+  "organizationName",
+  "fullName",
+  "logos",
+  "photos",
+  "emails",
+  "telephones",
+  "addresses",
+  "urls"
+];
+var resolveOrganizationProfileQuery = (query) => {
+  if (!query) return void 0;
+  if (!Array.isArray(query.Fields) || query.Fields.length === 0) return query;
+  const mergedFields = Array.from(/* @__PURE__ */ new Set([...query.Fields, ...ORGANIZATION_PROFILE_REQUIRED_FIELDS]));
+  return {
+    ...query,
+    Fields: mergedFields
+  };
+};
+var fetchOrganizationProfileById = async (id, query, context) => {
+  try {
+    const organization = await organizationsGetByIdServer({ id }, resolveOrganizationProfileQuery(query));
+    return toOrganizationProfile(organization, {
+      uiLanguage: context.uiLanguage,
+      displayNameFallback: context.fallbackName,
+      logoFallbackSrc: context.logoFallbackSrc
+    });
+  } catch (error) {
+    console.error(`[OrganizationProfile] Failed to load VCARD organization "${id}".`, error);
+    return {
+      id,
+      logoSrc: context.logoFallbackSrc,
+      displayName: context.fallbackName,
+      organizationName: context.fallbackName,
+      addressLines: [],
+      telephoneEntries: [],
+      socialLinks: []
+    };
+  }
+};
+var getOrganizationProfileById = async (id, query) => {
+  const serverConfig = getServerConfig();
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  return fetchOrganizationProfileById(id, query, {
+    uiLanguage,
+    fallbackName,
+    logoFallbackSrc
+  });
+};
+var getOrganizationProfileByIdCached = unstable_cache(
+  async (id, query, context) => withServerRequestContext(
+    { skipCookieTokenLookup: true },
+    () => fetchOrganizationProfileById(id, query, context)
+  ),
+  ["read-model", "organization-profile-v2"],
+  {
+    revalidate: READMODEL_CACHE_POLICY.vcardRevalidateSeconds,
+    tags: [
+      CREX_API_CACHE_TAG,
+      CREX_API_CACHE_VCARD_TAG,
+      CREX_READMODEL_CACHE_TAG,
+      CREX_READMODEL_CACHE_VCARD_TAG,
+      CREX_READMODEL_CACHE_ORGANIZATION_TAG
+    ]
+  }
+);
+var getOrganizationsProfiles = async (query) => {
+  const serverConfig = getServerConfig();
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  const result = await organizationsGetAllServer(query);
+  return result.items.map(
+    (organization) => toOrganizationProfile(organization, {
+      uiLanguage,
+      displayNameFallback: fallbackName,
+      logoFallbackSrc
+    })
+  );
+};
+var getOrganizationProfile = async () => {
+  const serverConfig = getServerConfig();
+  const rawVcardId = process.env.CREX_ORGANIZATION_VCARD_ID?.trim();
+  const encodedVcardId = process.env.CREX_ORGANIZATION_VCARD_ID_ENCODED?.trim();
+  const decodedEncodedVcardId = encodedVcardId ? decodeEncodedVcardId(encodedVcardId) : void 0;
+  const configuredVcardId = rawVcardId || decodedEncodedVcardId || serverConfig.organization?.vcardId?.trim();
+  if (!configuredVcardId) {
+    console.info("[OrganizationProfile] No VCARD organization ID configured. Using fallback branding.");
+    const logoFallbackSrc2 = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+    const fallbackName2 = serverConfig.projectName;
+    return {
+      logoSrc: logoFallbackSrc2,
+      displayName: fallbackName2,
+      organizationName: fallbackName2,
+      addressLines: [],
+      telephoneEntries: [],
+      socialLinks: []
+    };
+  }
+  if (rawVcardId && rawVcardId.startsWith("http") && !rawVcardId.includes("#")) {
+    console.warn(
+      `[OrganizationProfile] VCARD ID does not contain "#": "${rawVcardId}". If this value comes from .env, wrap it in quotes or use CREX_ORGANIZATION_VCARD_ID_ENCODED.`
+    );
+  }
+  const uiLanguage = resolveUiLanguage();
+  const fallbackName = serverConfig.projectName;
+  const logoFallbackSrc = serverConfig.organization?.logoFallbackSrc || DEFAULT_LOGO_SRC;
+  const context = {
+    uiLanguage,
+    fallbackName,
+    logoFallbackSrc
+  };
+  if (process.env.NODE_ENV === "test") {
+    return fetchOrganizationProfileById(configuredVcardId, void 0, context);
+  }
+  return getOrganizationProfileByIdCached(configuredVcardId, void 0, context);
+};
+var getOrganizationBranding = async () => {
+  const profile = await getOrganizationProfile();
+  return {
+    logoSrc: profile.logoSrc,
+    organizationName: profile.organizationName
+  };
+};
+
+// src/vcard/individual-profile.ts
+var toIndividualProfile = (individual, options) => {
+  const base = mapVCardEntityToBaseProfile(individual, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    fullName: base.displayName,
+    title: individual.title?.trim() || void 0,
+    role: individual.role?.trim() || void 0
+  };
+};
+var getIndividualProfileById = async (id, query) => {
+  const uiLanguage = resolveUiLanguage();
+  try {
+    const individual = await individualsGetByIdServer({ id }, query);
+    return toIndividualProfile(individual, {
+      uiLanguage,
+      displayNameFallback: id,
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    });
+  } catch (error) {
+    console.error(`[IndividualProfile] Failed to load VCARD individual "${id}".`, error);
+    return {
+      id,
+      logoSrc: DEFAULT_LOGO_SRC,
+      displayName: id,
+      fullName: id,
+      addressLines: [],
+      telephoneEntries: []
+    };
+  }
+};
+var getIndividualsProfiles = async (query) => {
+  const uiLanguage = resolveUiLanguage();
+  const result = await individualsGetAllServer(query);
+  return result.items.map(
+    (individual) => toIndividualProfile(individual, {
+      uiLanguage,
+      displayNameFallback: individual.id || "Unknown individual",
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    })
+  );
+};
+
+// src/vcard/vcard-profile.ts
+var toVCardProfile = (vcard, options) => {
+  const base = mapVCardEntityToBaseProfile(vcard, {
+    uiLanguage: options.uiLanguage,
+    displayNameFallback: options.displayNameFallback,
+    logoFallbackSrc: options.logoFallbackSrc
+  });
+  return {
+    ...base,
+    fullName: base.displayName
+  };
+};
+var getVCardProfileById = async (id, query) => {
+  const uiLanguage = resolveUiLanguage();
+  try {
+    const vcard = await vCardsGetByIdServer({ id }, query);
+    return toVCardProfile(vcard, {
+      uiLanguage,
+      displayNameFallback: id,
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    });
+  } catch (error) {
+    console.error(`[VCardProfile] Failed to load VCARD "${id}".`, error);
+    return {
+      id,
+      logoSrc: DEFAULT_LOGO_SRC,
+      displayName: id,
+      fullName: id,
+      addressLines: [],
+      telephoneEntries: []
+    };
+  }
+};
+var getVCardProfiles = async (query) => {
+  const uiLanguage = resolveUiLanguage();
+  const result = await vCardsGetAllServer(query);
+  return result.items.map(
+    (vcard) => toVCardProfile(vcard, {
+      uiLanguage,
+      displayNameFallback: vcard.id || "Unknown vCard",
+      logoFallbackSrc: DEFAULT_LOGO_SRC
+    })
+  );
+};
+export {
+  DEFAULT_LOGO_SRC,
+  buildTelephoneEntries,
+  decodeEncodedVcardId,
+  getIndividualProfileById,
+  getIndividualsProfiles,
+  getOrganizationBranding,
+  getOrganizationProfile,
+  getOrganizationProfileById,
+  getOrganizationsProfiles,
+  getServerConfig,
+  getVCardProfileById,
+  getVCardProfiles,
+  mapVCardEntityToBaseProfile,
+  normalizeEmail,
+  normalizeHref,
+  resolveLogoSource,
+  resolveSocialProviderLabel,
+  resolveTypedSocialLinks,
+  resolveUiLanguage
+};
+//# sourceMappingURL=index.mjs.map