@wix/himalaya-cli 0.1404.0 → 0.1406.0

package/templates/nonprofit-cause/himalaya.content.json

@@ -4,6 +4,9 @@
     "himi_account": {
       "displayName": "Profile"
     },
+    "himi_account_settings": {
+      "displayName": "Account Settings"
+    },
     "himi_app_info": {
       "displayName": "App Info"
     },

package/templates/nonprofit-cause/site-functions/README.md

@@ -0,0 +1,37 @@
+# My Account profile photo upload URL
+
+`himiMemberPhotoUploadUrl.js` is a Wix Velo HTTP function for minting a single
+public Media Manager upload URL for the signed-in member's profile photo. It
+requires the request to carry the member's Wix session through the authenticated
+REST invoke path. A direct anonymous `/_functions` request is not sufficient.
+
+The function reads the member identity with `currentMember.getMember()` before
+elevating only `files.generateFileUploadUrl()`. It accepts `mimeType` and
+`fileName`; the filename is generated on the server. It rejects caller-provided
+member, site, host, or folder values and allows JPEG, PNG, and WebP only. The
+generated upload is public because it is intended to be displayed as the member's
+profile photo. The upload URL is a bearer capability: keep it transient and do
+not log or persist it.
+
+The upload API does not expose a maximum byte-size option when minting this URL;
+the site function therefore cannot enforce the eventual PUT body size. The
+current native MediaField uploads directly to the signed URL and does not apply
+the `presigned_upload` capability's byte limit. Do not claim a size guarantee or
+add an invented size parameter to the Wix call.
+
+To install this function on a customer site, the site owner must publish it:
+
+```sh
+himi site function put himiMemberPhotoUploadUrl --method POST --source <file> --site <id> --url <site> --publish
+```
+
+Publishing makes the latest saved site revision live, which can include other
+unpublished site changes. Review that revision before publishing. This source
+change does not publish or invoke a live site.
+
+After installing the app, opt in by setting
+`HIMI_BRANDED_LITE_MEMBER_PHOTO_UPLOAD_FUNCTION=himiMemberPhotoUploadUrl` in the
+app runtime environment. The generated template reads this value at runtime;
+template generation replaces its local value with a placeholder so the
+generator machine's configuration is never baked into customer templates.
+Without the opt-in, the profile photo picker stays hidden.

package/templates/nonprofit-cause/site-functions/himiMemberPhotoUploadUrl.js

@@ -0,0 +1,90 @@
+// Member-authenticated upload URL mint for My Account profile photos.
+// This function is merged into a Wix site's backend/http-functions.js by
+// `himi site function put`; keep it self-contained so the CLI can preserve it.
+import { badRequest, forbidden, ok, serverError } from "wix-http-functions";
+import { elevate } from "wix-auth";
+import { files } from "wix-media.v2";
+import { currentMember } from "wix-members-backend";
+
+export async function post_himiMemberPhotoUploadUrl(request) {
+  const response = (builder, body) => builder({
+    headers: { "Content-Type": "application/json" },
+    body,
+  });
+
+  let input;
+  try {
+    input = await request.body.json();
+  } catch {
+    return response(badRequest, { error: "invalid_request" });
+  }
+
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return response(badRequest, { error: "invalid_request" });
+  }
+  const suppliedKeys = Object.keys(input);
+  if (suppliedKeys.some((key) => key !== "mimeType" && key !== "fileName")) {
+    return response(badRequest, { error: "invalid_request" });
+  }
+
+  const extensionByMimeType = Object.freeze({
+    "image/jpeg": "jpg",
+    "image/png": "png",
+    "image/webp": "webp",
+  });
+  const mimeType = input.mimeType;
+  const requestedFileName = input.fileName;
+  if (
+    typeof mimeType !== "string" || !Object.prototype.hasOwnProperty.call(extensionByMimeType, mimeType) ||
+    typeof requestedFileName !== "string" || requestedFileName.length < 1 || requestedFileName.length > 120 ||
+    /[\\/\u0000-\u001f\u007f]/.test(requestedFileName)
+  ) {
+    return response(badRequest, { error: "invalid_image" });
+  }
+
+  let member;
+  try {
+    // Resolve the session identity before elevating the upload mint. Never take
+    // a member, site, host, or folder identifier from the request body.
+    member = await currentMember.getMember({ fieldsets: ["FULL"] });
+  } catch {
+    return response(forbidden, { error: "member_required" });
+  }
+  const memberId = typeof member?._id === "string" ? member._id : "";
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(memberId)) {
+    return response(forbidden, { error: "member_required" });
+  }
+  if (String(member?.status ?? "").toUpperCase() === "BLOCKED") {
+    return response(forbidden, { error: "member_required" });
+  }
+
+  try {
+    const identityPrefix = memberId.replace(/-/g, "").slice(0, 10).toLowerCase();
+    const uniqueSuffix = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+    const fileName = `member-${identityPrefix}-profile-${uniqueSuffix}.${extensionByMimeType[mimeType]}`;
+    const generateUploadUrl = elevate(files.generateFileUploadUrl);
+    const result = await generateUploadUrl(mimeType, {
+      fileName,
+      private: false,
+    });
+    const uploadUrl = typeof result?.uploadUrl === "string" ? result.uploadUrl : "";
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(uploadUrl);
+    } catch {
+      return response(serverError, { error: "upload_unavailable" });
+    }
+    const hostname = parsedUrl.hostname.toLowerCase();
+    if (
+      parsedUrl.protocol !== "https:" || parsedUrl.username || parsedUrl.password ||
+      (parsedUrl.port && parsedUrl.port !== "443") || parsedUrl.hash ||
+      !(hostname === "wixmp.com" || hostname.endsWith(".wixmp.com"))
+    ) {
+      return response(serverError, { error: "upload_unavailable" });
+    }
+    return response(ok, { uploadUrl });
+  } catch {
+    // Do not return Wix errors or log the signed URL/token.
+    return response(serverError, { error: "upload_unavailable" });
+  }
+}

package/templates/nonprofit-cause/tier5-src/_shared/member-account-routes.ts

@@ -15,6 +15,8 @@ import { isHostedWorker } from "./hosted-checkout.js";
  *  time: the screens declare no `minBinaryVersion`, because a release takes its highest
  *  screen floor as its own and would then refuse every older binary. */
 export const MEMBER_ACCOUNT_ROUTES_MIN_BINARY = "1.4.0";
+export const MEMBER_MEDIA_FIELD_MIN_BINARY = "1.5.0";
+export const MEMBER_PASSWORD_ACTIONS_MIN_BINARY = "1.5.0";
 
 function atLeast(version: string, floor: string): boolean {
   const parts = (v: string) => v.split("-")[0].split(".").map((p) => Number.parseInt(p, 10) || 0);
@@ -31,13 +33,19 @@ export interface MemberAccountRoutes {
   addresses: boolean;
   /** Saved cards on the member's own site (My Wallet). */
   wallet: boolean;
+  /** Native MediaField image picking and presigned PUT support. */
+  mediaField: boolean;
+  /** Password credential actions introduced in HimalayaCore 1.5.0. */
+  passwordCredentials: boolean;
 }
 
 export async function memberAccountRoutes(): Promise<MemberAccountRoutes> {
-  if (isHostedWorker()) return { addresses: false, wallet: false };
+  if (isHostedWorker()) return { addresses: false, wallet: false, mediaField: false, passwordCredentials: false };
   const info = await getAppInfo().catch(() => undefined);
-  if (!info) return { addresses: false, wallet: false };
+  if (!info) return { addresses: false, wallet: false, mediaField: false, passwordCredentials: false };
   const native = info.platform === "ios" || info.platform === "android" || info.platform === "macos";
   const addresses = native && atLeast(info.binaryVersion ?? "", MEMBER_ACCOUNT_ROUTES_MIN_BINARY);
-  return { addresses, wallet: addresses && info.memberSiteBound === true };
+  const mediaField = native && atLeast(info.binaryVersion ?? "", MEMBER_MEDIA_FIELD_MIN_BINARY);
+  const passwordCredentials = native && atLeast(info.binaryVersion ?? "", MEMBER_PASSWORD_ACTIONS_MIN_BINARY);
+  return { addresses, wallet: addresses && info.memberSiteBound === true, mediaField, passwordCredentials };
 }

package/templates/nonprofit-cause/tier5-src/himi-branded-lite-account-settings/blocked-members.ts

@@ -0,0 +1,242 @@
+import { dispatch } from "@himalaya/dispatch";
+import { defineService } from "@himalaya/state";
+import { getMyMember, listCurrentMemberBlocking, unblockCurrentMember } from "@himalaya/wix-members";
+import { getMyData } from "@himalaya/wix-users";
+import { assertMemberAccess, memberAccess, type MemberAccess } from "../_shared/member-access.js";
+import { copyParam, stashCopy } from "../_shared/himi-copy.js";
+
+const PAGE_SIZE = 50;
+const MAX_READBACK_PAGES = 20;
+interface Row { memberId: string; label: string }
+interface State {
+  status: "loading" | "loaded" | "error";
+  identityStatus: "unresolved" | "guest" | "error" | "member";
+  hydrated: boolean; notIdentityResolved: boolean;
+  guest: boolean; notGuest: boolean; identityError: boolean; notIdentityError: boolean;
+  notMember: boolean; isMember: boolean; notLoading: boolean; notErrored: boolean;
+  hasError: boolean; errorText: string;
+  blockedMembers: Row[]; hasMembers: boolean; noMembers: boolean; hideEmpty: boolean;
+  nextCursor: string; hasMore: boolean; noMore: boolean; loadingMore: boolean;
+  confirmOpen: boolean; noConfirm: boolean; confirmMemberId: string; message: string;
+  currentMemberEmail: string; currentMemberScope: string; currentMemberId: string;
+}
+interface Identity extends MemberAccess { memberId: string }
+interface MyMemberResponse { member?: { id?: string } }
+interface Page { blockedMemberIds?: string[]; pagingMetadata?: { cursors?: { next?: string } } }
+
+const EMPTY: State = {
+  status: "loading", identityStatus: "unresolved", hydrated: false, notIdentityResolved: true,
+  guest: false, notGuest: true, identityError: false, notIdentityError: true,
+  notMember: true, isMember: false, notLoading: false, notErrored: true,
+  hasError: false, errorText: "", blockedMembers: [], hasMembers: false, noMembers: false, hideEmpty: true,
+  nextCursor: "", hasMore: false, noMore: true, loadingMore: false,
+  confirmOpen: false, noConfirm: true, confirmMemberId: "", message: "",
+  currentMemberEmail: "", currentMemberScope: "", currentMemberId: "",
+};
+
+function namedError(name: string, message: string): Error {
+  const error = new Error(message);
+  error.name = name;
+  return error;
+}
+function isNamed(error: unknown, name: string): boolean {
+  return (error as { name?: unknown } | null)?.name === name;
+}
+function clean(value: unknown): string { return typeof value === "string" ? value.trim() : ""; }
+function sameIdentity(a: Identity, b: Identity): boolean {
+  return a.email === b.email && a.scope === b.scope && a.memberId === b.memberId;
+}
+
+async function currentIdentity(): Promise<Identity | null> {
+  let raw: unknown;
+  let identityUnavailable = false;
+  try { raw = await dispatch("himi.wix.memberIdentity"); }
+  catch { identityUnavailable = true; }
+  const value = raw as { email?: unknown; payload?: { email?: unknown } } | null;
+  const emailValue = value?.email ?? value?.payload?.email;
+  let email = typeof emailValue === "string" ? emailValue.trim().toLowerCase() : "";
+  // Older native hosts predate the memberIdentity action but expose the profile through wix-users (the
+  // same rung memberAccess() uses). A host that fails BOTH ways is unavailable, never a guest.
+  if (!email && identityUnavailable) {
+    try {
+      const profile = await getMyData();
+      const legacy = profile.email ?? profile.contactEmail;
+      email = typeof legacy === "string" ? legacy.trim().toLowerCase() : "";
+    } catch { /* fall through to unavailable */ }
+    if (!email) throw namedError("IdentityUnavailable", "The current member identity could not be checked.");
+  }
+  if (!email) return null;
+  const access = await memberAccess();
+  if (!access.email || access.email !== email) throw namedError("IdentityUnavailable", "The current member identity could not be checked.");
+  const response = await getMyMember({ fieldsets: ["FULL"] }) as MyMemberResponse;
+  await assertMemberAccess(access);
+  const memberId = clean(response.member?.id);
+  if (!memberId) throw new Error("The signed-in member profile is unavailable.");
+  return { ...access, memberId };
+}
+
+async function assertCurrentIdentity(expected: Identity): Promise<void> {
+  const current = await currentIdentity();
+  if (!current || !sameIdentity(current, expected)) throw namedError("MemberChanged", "The signed-in member changed. Reload this section.");
+}
+
+function rows(ids: string[]): Row[] {
+  const seen = new Set<string>();
+  const result: Row[] = [];
+  for (const raw of ids) {
+    const memberId = clean(raw);
+    if (!memberId || seen.has(memberId)) continue;
+    seen.add(memberId);
+    // The member-owned endpoint returns IDs only. getMember(id) is APP-authenticated;
+    // never call it with a member token or suggest that names were loaded.
+    result.push({ memberId, label: copyParam("accountSettings.blockedMemberLabel", "Member") + " · " + memberId });
+  }
+  return result;
+}
+
+function withRows(state: State, blockedMembers: Row[], nextCursor: string): State {
+  return { ...state, blockedMembers, hasMembers: blockedMembers.length > 0,
+    noMembers: blockedMembers.length === 0,
+    hideEmpty: !(state.status === "loaded" && state.isMember && blockedMembers.length === 0),
+    nextCursor, hasMore: !!nextCursor, noMore: !nextCursor };
+}
+
+function memberState(identity: Identity): State {
+  return { ...EMPTY, status: "loaded", identityStatus: "member", hydrated: true, notIdentityResolved: false,
+    guest: false, notGuest: true, identityError: false, notIdentityError: true, notMember: false, isMember: true,
+    notLoading: true, notErrored: true, hasError: false, currentMemberEmail: identity.email,
+    currentMemberScope: identity.scope, currentMemberId: identity.memberId };
+}
+
+function failed(error: unknown): State {
+  const identityError = isNamed(error, "IdentityUnavailable") || isNamed(error, "MemberChanged");
+  const text = isNamed(error, "MemberChanged")
+    ? copyParam("accountSettings.blockedMembersChanged", "Your account changed. Reload your blocked members.")
+    : identityError
+      ? copyParam("accountSettings.blockedMembersIdentityError", "Your member identity could not be verified. Try again.")
+      : copyParam("accountSettings.blockedMembersError", "Blocked members could not be loaded. Try again.");
+  return { ...EMPTY, status: "error", identityStatus: identityError ? "error" : "member", hydrated: true,
+    notIdentityResolved: false, guest: false, notGuest: true, identityError, notIdentityError: !identityError,
+    notMember: false, isMember: true, notLoading: true, notErrored: false, hasError: true,
+    errorText: text, message: text };
+}
+
+async function readAll(identity: Identity): Promise<string[]> {
+  const ids: string[] = [];
+  const seenCursors = new Set<string>();
+  let cursor = "";
+  for (let i = 0; i < MAX_READBACK_PAGES; i += 1) {
+    await assertCurrentIdentity(identity);
+    const page = await listCurrentMemberBlocking({ cursorPaging: { limit: PAGE_SIZE, ...(cursor ? { cursor } : {}) } }) as Page;
+    await assertCurrentIdentity(identity);
+    ids.push(...(page.blockedMemberIds ?? []));
+    const next = clean(page.pagingMetadata?.cursors?.next);
+    if (!next) return [...new Set(ids.map(clean).filter(Boolean))];
+    if (seenCursors.has(next)) throw new Error("Blocked member paging did not advance.");
+    seenCursors.add(next);
+    cursor = next;
+  }
+  throw new Error("The blocked member list is too large to verify safely.");
+}
+
+let loadVersion = 0;
+let loadInFlight = false;
+let pageInFlight = false;
+let unblockInFlight = false;
+type Actions = {
+  load: (state: State, arg?: unknown) => Promise<State>;
+  loadMore: (state: State) => Promise<State | undefined>;
+  requestUnblock: (state: State, arg?: unknown) => State;
+  cancelUnblock: (state: State) => State;
+  confirmUnblock: (state: State) => Promise<State | undefined>;
+};
+const svc: ReturnType<typeof defineService<State, Actions>> = defineService<State, Actions>("himiBrandedAccountBlockedMembers", {
+  state: { ...EMPTY },
+  notHydrated: ["status", "identityStatus", "hydrated", "notIdentityResolved", "guest", "notGuest", "identityError", "notIdentityError", "notMember", "isMember", "notLoading", "notErrored", "hasError", "errorText", "blockedMembers", "hasMembers", "noMembers", "hideEmpty", "nextCursor", "hasMore", "noMore", "loadingMore", "confirmOpen", "noConfirm", "confirmMemberId", "message", "currentMemberEmail", "currentMemberScope", "currentMemberId"],
+  actions: {
+    load: async (_state, arg): Promise<State> => {
+      if (loadInFlight) return svc.getState() as State;
+      loadInFlight = true;
+      stashCopy(arg);
+      const version = ++loadVersion;
+      try {
+        const identity = await currentIdentity();
+        if (version !== loadVersion) return svc.getState() as State;
+        if (!identity) return { ...EMPTY, status: "loaded", identityStatus: "guest", hydrated: true,
+          notIdentityResolved: false, guest: true, notGuest: false, notMember: true, notLoading: true, noMembers: false };
+        await assertCurrentIdentity(identity);
+        const page = await listCurrentMemberBlocking({ cursorPaging: { limit: PAGE_SIZE } }) as Page;
+        await assertCurrentIdentity(identity);
+        if (version !== loadVersion) return svc.getState() as State;
+        return withRows(memberState(identity), rows(page.blockedMemberIds ?? []), clean(page.pagingMetadata?.cursors?.next));
+      } catch (error) {
+        if (version !== loadVersion) return svc.getState() as State;
+        return failed(error);
+      } finally { loadInFlight = false; }
+    },
+    loadMore: async (state) => {
+      if (pageInFlight || state.status !== "loaded" || !state.isMember || !state.hasMore) return undefined;
+      pageInFlight = true;
+      // A newer load() supersedes this page: return undefined (commit nothing) instead of writing back
+      // the pre-await snapshot, which would replace the fresh list or its error state.
+      const version = loadVersion;
+      try {
+        const identity = await currentIdentity();
+        if (version !== loadVersion) return undefined;
+        const expected: Identity = { email: state.currentMemberEmail, scope: state.currentMemberScope, memberId: state.currentMemberId };
+        if (!identity || !sameIdentity(identity, expected)) return failed(namedError("MemberChanged", "The signed-in member changed. Reload this section."));
+        await assertCurrentIdentity(identity);
+        const page = await listCurrentMemberBlocking({ cursorPaging: { limit: PAGE_SIZE, cursor: state.nextCursor } }) as Page;
+        await assertCurrentIdentity(identity);
+        if (version !== loadVersion) return undefined;
+        const combined = rows([...state.blockedMembers.map((item) => item.memberId), ...(page.blockedMemberIds ?? [])]);
+        return { ...withRows(state, combined, clean(page.pagingMetadata?.cursors?.next)), loadingMore: false };
+      } catch (error) {
+        if (version !== loadVersion) return undefined;
+        if (isNamed(error, "MemberChanged") || isNamed(error, "IdentityUnavailable")) return failed(error);
+        return { ...state, status: "error", notLoading: true, notErrored: false, hasError: true,
+          errorText: copyParam("accountSettings.blockedMembersError", "Blocked members could not be loaded. Try again."),
+          blockedMembers: state.blockedMembers, hasMembers: state.blockedMembers.length > 0,
+          noMembers: false, hideEmpty: true, nextCursor: state.nextCursor, hasMore: true, noMore: false };
+      } finally { pageInFlight = false; }
+    },
+    requestUnblock: (state, arg) => {
+      const memberId = clean((arg as { memberId?: unknown } | undefined)?.memberId);
+      if (state.status !== "loaded" || !state.isMember || !memberId || !state.blockedMembers.some((item) => item.memberId === memberId)) return state;
+      return { ...state, confirmOpen: true, noConfirm: false, confirmMemberId: memberId,
+        message: "", errorText: "", hasError: false, notErrored: true };
+    },
+    cancelUnblock: (state) => ({ ...state, confirmOpen: false, noConfirm: true, confirmMemberId: "" }),
+    confirmUnblock: async (state) => {
+      if (unblockInFlight || !state.confirmOpen || state.status !== "loaded" || !state.isMember) return undefined;
+      const memberId = state.confirmMemberId;
+      if (!memberId || !state.blockedMembers.some((item) => item.memberId === memberId)) return undefined;
+      unblockInFlight = true;
+      let mutationAttempted = false;
+      try {
+        const identity = await currentIdentity();
+        const expected: Identity = { email: state.currentMemberEmail, scope: state.currentMemberScope, memberId: state.currentMemberId };
+        if (!identity || !sameIdentity(identity, expected)) return failed(namedError("MemberChanged", "The signed-in member changed. Reload this section."));
+        await assertCurrentIdentity(identity);
+        mutationAttempted = true;
+        loadVersion += 1; // a page requested before the unblock must not re-add the member...
+        await unblockCurrentMember(memberId);
+        await assertCurrentIdentity(identity);
+        const ids = await readAll(identity);
+        loadVersion += 1; // ...nor one requested while it was in flight: this authoritative list wins
+        if (ids.includes(memberId)) return { ...state, confirmOpen: true, noConfirm: false, hasError: true, notErrored: false,
+          errorText: copyParam("accountSettings.blockedUnblockStillListed", "This member still appears blocked. Reload the list before trying again.") };
+        const refreshed = rows(ids);
+        return { ...withRows({ ...state, confirmOpen: false, noConfirm: true, confirmMemberId: "", hasError: false,
+          notErrored: true, errorText: "", message: copyParam("accountSettings.blockedUnblocked", "Member unblocked.") }, refreshed, "") };
+      } catch (error) {
+        if (isNamed(error, "MemberChanged") || isNamed(error, "IdentityUnavailable")) return failed(error);
+        if (mutationAttempted) return { ...failed(error), errorText: copyParam("accountSettings.blockedUnblockUnconfirmed", "Could not confirm the updated blocked list. Reload and try again."), message: copyParam("accountSettings.blockedUnblockUnconfirmed", "Could not confirm the updated blocked list. Reload and try again."), confirmOpen: false, noConfirm: true };
+        return { ...state, confirmOpen: true, noConfirm: false, hasError: true, notErrored: false,
+          errorText: copyParam("accountSettings.blockedUnblockError", "This member could not be unblocked. Try again.") };
+      } finally { unblockInFlight = false; }
+    },
+  },
+});
+
+export { svc };