keystone-design-bootstrap 1.0.55 → 1.0.57

package/src/next/routes/chat.ts

@@ -5,6 +5,10 @@
  *   // app/api/chat/route.ts
  *   export { GET, POST } from 'keystone-design-bootstrap/next/routes/chat';
  *
+ * Supports both anonymous (session-based) and authenticated (contact-driven) flows.
+ * Both flows hit the same backend endpoint (`/public/messages`); the discriminator
+ * is whether `identifier` (session string) or `contact_id` (integer) is supplied.
+ *
  * Env (server-side only):
  * - API_URL (default: http://localhost:3000/api/v1)
  * - API_KEY
@@ -26,105 +30,73 @@ export function createChatRouteHandlers(deps?: { NextResponse?: { json: JsonResp
   const json: JsonResponder = deps?.NextResponse?.json ?? ((body, init) => Response.json(body, init));
 
   return {
+    // POST /api/chat — send a message (session-based or contact-driven)
     POST: async (request: Request): Promise<Response> => {
       try {
         const body = await request.json();
-        const { identifier, body: messageBody, display_name, page_url } = body;
+        const { identifier, contact_id, body: messageBody, display_name, page_url } = body;
 
-        if (!identifier || !messageBody) {
+        if (!messageBody) {
+          return json({ success: false, error: 'Message body is required.' }, { status: 400 });
+        }
+        if (!identifier && !contact_id) {
           return json(
-            { success: false, error: 'Identifier and message body are required.' },
+            { success: false, error: 'identifier or contact_id is required.' },
             { status: 400 }
           );
         }
 
         const response = await fetch(`${API_URL}/public/messages`, {
           method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'X-API-Key': API_KEY,
-          },
-          body: JSON.stringify({
-            identifier,
-            body: messageBody,
-            display_name,
-            page_url,
-          }),
+          headers: { 'Content-Type': 'application/json', 'X-API-Key': API_KEY },
+          body: JSON.stringify({ identifier, contact_id, body: messageBody, display_name, page_url }),
         });
 
         const data = await response.json();
-
         if (!response.ok) {
           return json(
-            {
-              success: false,
-              error: data.error || 'Failed to send message. Please try again.',
-            },
+            { success: false, error: data.error || 'Failed to send message. Please try again.' },
             { status: response.status }
           );
         }
-
-        return json({
-          success: true,
-          data: data.data,
-        });
+        return json({ success: true, data: data.data });
       } catch (error) {
         console.error('Chat message error:', error);
-        return json(
-          {
-            success: false,
-            error: 'Network error. Please try again later.',
-          },
-          { status: 500 }
-        );
+        return json({ success: false, error: 'Network error. Please try again later.' }, { status: 500 });
       }
     },
 
+    // GET /api/chat?identifier=... or ?contact_id=... — load message history
     GET: async (request: Request): Promise<Response> => {
       try {
         const { searchParams } = new URL(request.url);
         const identifier = searchParams.get('identifier');
+        const contactId = searchParams.get('contact_id');
 
-        if (!identifier) {
-          return json({ success: false, error: 'Identifier is required.' }, { status: 400 });
+        if (!identifier && !contactId) {
+          return json({ success: false, error: 'identifier or contact_id is required.' }, { status: 400 });
         }
 
-        const response = await fetch(
-          `${API_URL}/public/messages?identifier=${encodeURIComponent(identifier)}`,
-          {
-            headers: {
-              'X-API-Key': API_KEY,
-            },
-          }
-        );
+        const query = contactId
+          ? `contact_id=${encodeURIComponent(contactId)}`
+          : `identifier=${encodeURIComponent(identifier!)}`;
 
-        const data = await response.json();
+        const response = await fetch(`${API_URL}/public/messages?${query}`, {
+          headers: { 'X-API-Key': API_KEY },
+        });
 
+        const data = await response.json();
         if (!response.ok) {
           return json(
-            {
-              success: false,
-              error: data.error || 'Failed to load messages.',
-            },
+            { success: false, error: data.error || 'Failed to load messages.' },
             { status: response.status }
           );
         }
-
-        return json({
-          success: true,
-          data: data.data || [],
-        });
+        return json({ success: true, data: data.data || [] });
       } catch (error) {
         console.error('Chat history error:', error);
-        return json(
-          {
-            success: false,
-            error: 'Network error. Please try again later.',
-          },
-          { status: 500 }
-        );
+        return json({ success: false, error: 'Network error. Please try again later.' }, { status: 500 });
       }
     },
   };
 }
-

package/src/next/routes/consumer-auth.ts

@@ -0,0 +1,180 @@
+/**
+ * Consumer auth API route handlers for Next.js App Router.
+ *
+ * Usage in a customer site:
+ *   // app/api/consumer/[action]/route.ts
+ *   import { NextResponse } from 'next/server';
+ *   import { createConsumerAuthHandlers } from 'keystone-design-bootstrap/next/routes/consumer-auth';
+ *   export const { POST } = createConsumerAuthHandlers({ NextResponse });
+ *
+ * Handles: initiate, login, signup, logout
+ *
+ * Env (server-side only):
+ * - API_URL (default: http://localhost:3000/api/v1)
+ * - API_KEY
+ */
+
+import { CONSUMER_TOKEN_COOKIE } from '../../lib/consumer-session';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type NextResponseLike = { json: (body: unknown, init?: ResponseInit) => any };
+
+const COOKIE_MAX_AGE = 60 * 60 * 24 * 30; // 30 days
+
+function getApiUrl(): string {
+  return process.env.API_URL || 'http://localhost:3000/api/v1';
+}
+
+function getApiKey(): string {
+  return process.env.API_KEY || '';
+}
+
+function apiHeaders(): Record<string, string> {
+  const key = getApiKey();
+  return {
+    'Content-Type': 'application/json',
+    ...(key ? { 'X-API-Key': key } : {}),
+  };
+}
+
+// POST /api/consumer/initiate
+// Looks up an existing user by email or phone, creating a Contact if needed.
+// Returns { exists, firstName, hasPassword }.
+async function handleInitiate(request: Request, NR: NextResponseLike): Promise<Response> {
+  const body = await request.json().catch(() => ({})) as Record<string, unknown>;
+  const { email, phone } = body;
+
+  if (!email && !phone) {
+    return NR.json({ exists: null });
+  }
+
+  try {
+    const res = await fetch(`${getApiUrl()}/consumer/auth/initiate`, {
+      method: 'POST',
+      headers: apiHeaders(),
+      body: JSON.stringify({ email: email || undefined, phone: phone || undefined }),
+    });
+
+    if (res.status === 404) return NR.json({ exists: false });
+    if (!res.ok) return NR.json({ exists: null });
+
+    const json = await res.json().catch(() => ({}));
+    const data = json.data as Record<string, unknown> | undefined;
+    return NR.json({
+      exists: true,
+      firstName: data?.first_name ?? undefined,
+      hasPassword: data?.has_password != null ? Boolean(data.has_password) : true,
+    });
+  } catch {
+    return NR.json({ exists: null });
+  }
+}
+
+// POST /api/consumer/login
+// Authenticates an existing user. Sets HttpOnly JWT cookie on success.
+// Returns {} on success or { error, code } on failure.
+async function handleLogin(request: Request, NR: NextResponseLike): Promise<Response> {
+  const body = await request.json().catch(() => ({})) as Record<string, string>;
+  const { email, phone, password } = body;
+
+  if (!email && !phone) return NR.json({ error: 'Email or phone is required.' }, { status: 422 });
+  if (!password) return NR.json({ error: 'Password is required.' }, { status: 422 });
+
+  const res = await fetch(`${getApiUrl()}/consumer/auth/login`, {
+    method: 'POST',
+    headers: apiHeaders(),
+    body: JSON.stringify({ email: email || undefined, phone: phone || undefined, password }),
+  });
+
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    return NR.json(
+      { error: json.error || 'Login failed. Please try again.', code: json.code },
+      { status: res.status }
+    );
+  }
+
+  const token = json.data?.token;
+  if (!token) return NR.json({ error: 'No token received.' }, { status: 500 });
+
+  const response = NR.json({});
+  response.cookies.set(CONSUMER_TOKEN_COOKIE, token, {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === 'production',
+    sameSite: 'lax',
+    path: '/',
+    maxAge: COOKIE_MAX_AGE,
+  });
+  return response;
+}
+
+// POST /api/consumer/signup
+// Creates a new account (or claims an existing contact). Sets HttpOnly JWT cookie on success.
+// Returns {} on success or { error } on failure.
+async function handleSignup(request: Request, NR: NextResponseLike): Promise<Response> {
+  const body = await request.json().catch(() => ({})) as Record<string, string>;
+  const { email, phone, password, password_confirmation, first_name, last_name } = body;
+
+  if (!email && !phone) return NR.json({ error: 'Email or phone is required.' }, { status: 422 });
+
+  const res = await fetch(`${getApiUrl()}/consumer/auth/signup`, {
+    method: 'POST',
+    headers: apiHeaders(),
+    body: JSON.stringify({
+      email: email || undefined,
+      phone: phone || undefined,
+      password,
+      password_confirmation,
+      first_name: first_name || undefined,
+      last_name: last_name || undefined,
+    }),
+  });
+
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    return NR.json({ error: json.error || 'Signup failed. Please try again.' }, { status: res.status });
+  }
+
+  const token = json.data?.token;
+  if (!token) return NR.json({ error: 'No token received.' }, { status: 500 });
+
+  const response = NR.json({ claimed: json.data?.claimed ?? false });
+  response.cookies.set(CONSUMER_TOKEN_COOKIE, token, {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === 'production',
+    sameSite: 'lax',
+    path: '/',
+    maxAge: COOKIE_MAX_AGE,
+  });
+  return response;
+}
+
+// POST /api/consumer/logout
+// Clears the JWT cookie.
+async function handleLogout(_request: Request, NR: NextResponseLike): Promise<Response> {
+  const response = NR.json({ success: true });
+  response.cookies.delete(CONSUMER_TOKEN_COOKIE);
+  return response;
+}
+
+/**
+ * Creates a single POST handler that routes to the correct auth action based on
+ * the dynamic `[action]` path segment.
+ *
+ * Compatible with Next.js 14 (sync params) and 15 (async params).
+ */
+export function createConsumerAuthHandlers({ NextResponse }: { NextResponse: NextResponseLike }) {
+  return {
+    POST: async (
+      request: Request,
+      context: { params: Promise<{ action: string }> | { action: string } }
+    ): Promise<Response> => {
+      const { action } = await Promise.resolve(context.params);
+      if (action === 'initiate') return handleInitiate(request, NextResponse);
+      if (action === 'login') return handleLogin(request, NextResponse);
+      if (action === 'signup') return handleSignup(request, NextResponse);
+      if (action === 'logout') return handleLogout(request, NextResponse);
+      return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    },
+  };
+}

package/src/types/api/consumer.ts

@@ -0,0 +1,39 @@
+/** Consumer and messaging types (aligned with Rails ConsumerSerializer and conversation endpoints). */
+
+export interface Consumer {
+  id: number;
+  email: string | null;
+  phone: string | null;
+  primary_identifier: string | null;
+  contacts?: ConsumerContact[];
+}
+
+export interface ConsumerContact {
+  id: number;
+  display_name: string;
+  account?: { id: number; name: string; slug?: string };
+}
+
+export interface ConversationSummary {
+  contact_id: number;
+  business?: { id: number; name: string; company_name?: string };
+  last_message_at: string | null;
+  last_message_preview?: string | null;
+  message_count: number;
+}
+
+export interface Message {
+  id: number;
+  body: string | null;
+  /** "outbound" = sent by the business; "inbound" = sent by the contact/member. */
+  direction: 'inbound' | 'outbound';
+  sender_type: 'contact' | 'agent' | 'human';
+  sender_display_name?: string;
+  created_at: string;
+}
+
+export interface ContactSummary {
+  id: number;
+  display_name: string;
+  business?: { id: number; name: string; company_name?: string };
+}

package/src/types/api/offer.ts

@@ -6,7 +6,7 @@ export interface OfferPublic {
   name: string;
   description: string | null;
   value_terms: string | null;
-  active: boolean;
+  active?: boolean;
   expires_at?: string | null;
   expired?: boolean;
   photo_attachments?: PhotoAttachment[];

package/src/types/api/package.ts

@@ -0,0 +1,20 @@
+import type { PhotoAttachment } from './photos';
+import type { OfferPublic } from './offer';
+
+export interface PackageItem {
+  quantity: number;
+  service_item?: { id: number; name: string; slug: string; summary?: string | null };
+}
+
+export interface Package {
+  id: number;
+  name: string;
+  slug: string;
+  summary?: string | null;
+  description_markdown?: string | null;
+  pricing_info?: string | null;
+  price_cents?: number | null;
+  photo_attachments?: PhotoAttachment[];
+  package_items?: PackageItem[];
+  offers?: OfferPublic[];
+}

package/src/types/api/service.ts

@@ -1,4 +1,6 @@
-// Service type definitions (aligned with Rails ServiceSerializer)
+import type { PhotoAttachment } from './photos';
+import type { OfferPublic } from './offer';
+
 export interface Service {
   id: number;
   name: string;
@@ -9,27 +11,12 @@ export interface Service {
   features_markdown?: string;
   featured: boolean;
   sort_order: number;
-  photo_attachments?: Array<{
-    id: number;
-    featured: boolean;
-    attachable_id?: number;
-    attachable_type?: string;
-    photo?: {
-      id: number;
-      title: string;
-      thumbnail_url?: string;
-      medium_url?: string;
-      large_url?: string;
-      original_url?: string;
-    };
-  }>;
-  /** Menu items under this service category (when loaded with associations). */
+  photo_attachments?: PhotoAttachment[];
   service_items?: ServiceItem[];
   created_at: string;
   updated_at: string;
 }
 
-/** Single menu item under a service category. */
 export interface ServiceItem {
   id: number;
   name: string;
@@ -41,13 +28,8 @@ export interface ServiceItem {
   duration_minutes?: number | null;
   sort_order: number;
   service_id?: number;
-  /** Present when loaded for public/menu (from related service’s photos). */
-  photo_attachments?: Array<{
-    id: number;
-    photo?: { thumbnail_url?: string; medium_url?: string; large_url?: string; original_url?: string; title?: string; alt_text?: string };
-  }>;
-  /** Active offers that apply to this menu item (public API). */
-  offers?: import('./offer').OfferPublic[];
+  photo_attachments?: PhotoAttachment[];
+  offers?: OfferPublic[];
 }
 
 export interface ServiceParams {

package/src/types/index.ts

@@ -9,12 +9,14 @@ export * from './config';
 // Re-export API types
 export * from './api/blog-post';
 export * from './api/company-information';
+export * from './api/consumer';
 export * from './api/contact';
 export * from './api/form';
 export * from './api/faq';
 export * from './api/job-posting';
 export * from './api/location';
 export * from './api/offer';
+export * from './api/package';
 export * from './api/photos';
 export * from './api/service';
 export * from './api/social-post';

package/src/utils/phone-helpers.ts

@@ -0,0 +1,27 @@
+import type countries from './countries';
+
+type Country = (typeof countries)[0];
+
+/** Get national-format mask from country by stripping the country code prefix (e.g. "+1 (###) ###-####" → "(###) ###-####"). */
+export function getNationalMask(country: Country | undefined): string {
+  if (!country?.phoneMask) return '';
+  const code = country.phoneCode.startsWith('+') ? country.phoneCode : `+${country.phoneCode}`;
+  const escaped = code.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return country.phoneMask.replace(new RegExp(`^\\s*${escaped}[\\s-]*`), '').trim();
+}
+
+/** Format a raw digit string into a mask pattern where '#' represents one digit. No trailing literals so backspace works naturally. */
+export function formatDigitsToMask(digits: string, mask: string): string {
+  if (digits.length === 0) return '';
+  let i = 0;
+  let out = '';
+  for (const c of mask) {
+    if (c === '#') {
+      if (i < digits.length) out += digits[i++];
+      else break;
+    } else if (i < digits.length) {
+      out += c;
+    }
+  }
+  return out;
+}

package/dist/blog-post-DGjaJ3wf.d.ts

@@ -1,50 +0,0 @@
-import { P as PhotoAttachment } from './website-photos-Bm-CBK9g.js';
-
-interface BlogPost {
-    id: number;
-    title: string;
-    slug: string;
-    status: string;
-    published_at?: string;
-    excerpt_markdown?: string;
-    content_markdown: string;
-    featured: boolean;
-    seo_title?: string;
-    seo_description?: string;
-    seo_keywords?: string;
-    created_at: string;
-    updated_at: string;
-    photo_attachments?: PhotoAttachment[];
-    blog_post_authors?: BlogPostAuthor[];
-    blog_post_tags?: BlogPostTag[];
-}
-interface BlogPostParams {
-    status?: string;
-    author_id?: number;
-    tag_id?: number;
-    q?: string;
-    page?: number;
-    per_page?: number;
-    featured?: boolean;
-}
-type BlogPostResponse = BlogPost[];
-interface BlogPostAuthor {
-    id: number;
-    name: string;
-    slug: string;
-    bio_markdown?: string;
-    active: boolean;
-    created_at: string;
-    updated_at: string;
-    photo_attachments?: PhotoAttachment[];
-}
-interface BlogPostTag {
-    id: number;
-    name: string;
-    slug: string;
-    description?: string;
-    created_at: string;
-    updated_at: string;
-}
-
-export type { BlogPost as B, BlogPostAuthor as a, BlogPostParams as b, BlogPostResponse as c, BlogPostTag as d };

package/dist/contexts/index.d.ts

@@ -1,13 +0,0 @@
-import * as React$1 from 'react';
-import { Theme } from '../themes/index.js';
-
-interface ThemeContextValue {
-    theme: Theme;
-}
-declare function ThemeProvider({ theme, children }: {
-    theme: Theme;
-    children: React.ReactNode;
-}): React$1.JSX.Element;
-declare function useTheme(): ThemeContextValue;
-
-export { ThemeProvider, useTheme };