@pevey/medusa 2.14.2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Lacey Pevey
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,220 @@
+# @pevey/medusa
+
+Extended Medusa JS SDK with support for custom plugins. Drop-in replacement for `@medusajs/js-sdk` that adds typed methods for Reviews, Content, Forms, and Analytics alongside all core Medusa functionality.
+
+## Installation
+
+```bash
+yarn add @pevey/medusa
+```
+
+## Setup
+
+```ts
+import Medusa from '@pevey/medusa'
+
+const sdk = new Medusa({
+  baseUrl: 'http://localhost:9000',
+  publishableKey: 'pk_...',
+  auth: {
+    type: 'session'
+  }
+})
+```
+
+All [configuration options](https://docs.medusajs.com/resources/js-sdk#configuration) from `@medusajs/js-sdk` are supported, plus:
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `analytics.salesChannelId` | `string` | Default sales channel ID for analytics events |
+| `analytics.cartId` | `string` | Default actor ID (typically cart ID) |
+| `analytics.batchSize` | `number` | Flush when batch reaches this size (default: 10) |
+| `analytics.flushInterval` | `number` | Flush interval in ms (default: 2000) |
+
+## Store
+
+All core store methods from `@medusajs/js-sdk` are available unchanged:
+
+```ts
+const regions = await sdk.store.region.list()
+const cart = await sdk.store.cart.create({})
+const products = await sdk.store.product.list()
+```
+
+### Reviews
+
+```ts
+// List approved reviews for a product
+const { reviews, count } = await sdk.store.review.list('prod_123')
+
+// Submit a review (requires customer authentication)
+const { review } = await sdk.store.review.create('prod_123', {
+  rating: 5,
+  body: 'Excellent quality',
+  author_name: 'Alice',
+  author_email: 'alice@example.com'
+})
+```
+
+### Content
+
+```ts
+// List content collections
+const { content_collections } = await sdk.store.content.list()
+
+// Get a specific collection
+const { content_collection } = await sdk.store.content.retrieve('blog')
+
+// List published items in a collection
+const { content_items } = await sdk.store.content.listItems('blog', {
+  tag: 'announcements',
+  limit: 10
+})
+
+// Get a specific content item
+const { content_item } = await sdk.store.content.retrieveItem('blog', 'hello-world')
+```
+
+### Forms
+
+```ts
+// Submit a form
+const { submitted } = await sdk.store.form.submit('contact', {
+  data: {
+    name: 'Alice',
+    email: 'alice@example.com',
+    message: 'Hello!'
+  },
+  cf_turnstile_response: 'token...'  // optional, if Turnstile is enabled
+})
+```
+
+### Products (Expanded Types)
+
+`sdk.store.product.list()` and `sdk.store.product.retrieve()` return an expanded `StoreProduct` type that includes review data when the reviews plugin is installed:
+
+```ts
+const { products } = await sdk.store.product.list()
+
+// products[0].reviews       — Review[]
+// products[0].review_stats  — { average_rating: number, count: number }
+```
+
+## Admin
+
+All core admin methods from `@medusajs/js-sdk` are available unchanged:
+
+```ts
+const { orders } = await sdk.admin.order.list()
+const { products } = await sdk.admin.product.list()
+```
+
+### Reviews
+
+```ts
+// List reviews with filtering
+const { reviews } = await sdk.admin.review.list({
+  status: 'pending',
+  product_id: 'prod_123'
+})
+
+// Get a single review
+const { review } = await sdk.admin.review.retrieve('rev_123')
+
+// Update a review
+await sdk.admin.review.update('rev_123', { status: 'approved' })
+
+// Delete a review
+await sdk.admin.review.delete('rev_123')
+
+// Bulk approve/reject
+await sdk.admin.review.approve(['rev_123', 'rev_456'])
+await sdk.admin.review.reject(['rev_789'])
+```
+
+## Analytics
+
+Privacy-focused event tracking with automatic batching. Events are sent to the Mildred analytics endpoint at `/store/ping`.
+
+```ts
+// Track an event
+sdk.analytics.track('product_viewed', {
+  properties: { product_id: 'prod_123' }
+})
+
+// Identify a customer
+sdk.analytics.identify('cust_123', {
+  anonymous_id: 'cart_abc'
+})
+
+// Set default actor/sales channel
+sdk.analytics.setCartId('cart_abc')
+sdk.analytics.setSalesChannelId('sc_123')
+
+// Force flush queued events
+await sdk.analytics.flush()
+
+// Cleanup (flushes and stops timer)
+await sdk.analytics.destroy()
+```
+
+**Browser behavior:** Events are queued and flushed in batches (default: 10 events or every 2 seconds). On page unload, remaining events are sent via `navigator.sendBeacon` for reliability.
+
+**Server behavior:** Events are sent immediately with no batching.
+
+## Authentication
+
+Authentication works exactly like `@medusajs/js-sdk`:
+
+```ts
+// Customer login
+await sdk.auth.login('customer', 'emailpass', {
+  email: 'customer@example.com',
+  password: 'password'
+})
+
+// Customer registration
+await sdk.auth.register('customer', 'emailpass', {
+  email: 'customer@example.com',
+  password: 'password'
+})
+
+// Logout
+await sdk.auth.logout()
+```
+
+## Raw Client
+
+For endpoints not covered by the SDK, use `sdk.client.fetch()`:
+
+```ts
+const result = await sdk.client.fetch('/admin/custom-endpoint', {
+  method: 'POST',
+  body: { key: 'value' }
+})
+```
+
+## Types
+
+All types are exported for use in your application:
+
+```ts
+import type {
+  // Custom plugin types
+  Review,
+  StoreCreateReviewInput,
+  ContentCollection,
+  ContentItem,
+  FormSubmitInput,
+  TrackOptions,
+
+  // Expanded core types
+  StoreProduct,
+  AdminProduct,
+
+  // SDK config types
+  MedusaConfig,
+  Config,
+  ClientHeaders,
+} from '@pevey/medusa'
+```

package/dist/admin.d.ts

@@ -0,0 +1,57 @@
+import { Client, Admin as MedusaAdmin } from '@medusajs/js-sdk';
+import { createAdminReviewResource } from './resources/admin/review';
+type CoreAdmin = InstanceType<typeof MedusaAdmin>;
+export declare class Admin {
+    private core;
+    review: ReturnType<typeof createAdminReviewResource>;
+    constructor(client: Client);
+    get apiKey(): CoreAdmin['apiKey'];
+    get campaign(): CoreAdmin['campaign'];
+    get claim(): CoreAdmin['claim'];
+    get currency(): CoreAdmin['currency'];
+    get customer(): CoreAdmin['customer'];
+    get customerGroup(): CoreAdmin['customerGroup'];
+    get draftOrder(): CoreAdmin['draftOrder'];
+    get exchange(): CoreAdmin['exchange'];
+    get fulfillment(): CoreAdmin['fulfillment'];
+    get fulfillmentProvider(): CoreAdmin['fulfillmentProvider'];
+    get fulfillmentSet(): CoreAdmin['fulfillmentSet'];
+    get inventoryItem(): CoreAdmin['inventoryItem'];
+    get invite(): CoreAdmin['invite'];
+    get locale(): CoreAdmin['locale'];
+    get notification(): CoreAdmin['notification'];
+    get order(): CoreAdmin['order'];
+    get orderEdit(): CoreAdmin['orderEdit'];
+    get payment(): CoreAdmin['payment'];
+    get paymentCollection(): CoreAdmin['paymentCollection'];
+    get plugin(): CoreAdmin['plugin'];
+    get priceList(): CoreAdmin['priceList'];
+    get pricePreference(): CoreAdmin['pricePreference'];
+    get product(): CoreAdmin['product'];
+    get productCategory(): CoreAdmin['productCategory'];
+    get productCollection(): CoreAdmin['productCollection'];
+    get productTag(): CoreAdmin['productTag'];
+    get productType(): CoreAdmin['productType'];
+    get productVariant(): CoreAdmin['productVariant'];
+    get promotion(): CoreAdmin['promotion'];
+    get refundReason(): CoreAdmin['refundReason'];
+    get region(): CoreAdmin['region'];
+    get reservation(): CoreAdmin['reservation'];
+    get return(): CoreAdmin['return'];
+    get returnReason(): CoreAdmin['returnReason'];
+    get salesChannel(): CoreAdmin['salesChannel'];
+    get shippingOption(): CoreAdmin['shippingOption'];
+    get shippingOptionType(): CoreAdmin['shippingOptionType'];
+    get shippingProfile(): CoreAdmin['shippingProfile'];
+    get stockLocation(): CoreAdmin['stockLocation'];
+    get store(): CoreAdmin['store'];
+    get taxProvider(): CoreAdmin['taxProvider'];
+    get taxRate(): CoreAdmin['taxRate'];
+    get taxRegion(): CoreAdmin['taxRegion'];
+    get translation(): CoreAdmin['translation'];
+    get upload(): CoreAdmin['upload'];
+    get user(): CoreAdmin['user'];
+    get views(): CoreAdmin['views'];
+    get workflowExecution(): CoreAdmin['workflowExecution'];
+}
+export {};

package/dist/admin.js

@@ -0,0 +1,57 @@
+import { Admin as MedusaAdmin } from '@medusajs/js-sdk';
+import { createAdminReviewResource } from './resources/admin/review';
+export class Admin {
+    constructor(client) {
+        this.core = new MedusaAdmin(client);
+        this.review = createAdminReviewResource(client);
+    }
+    // ── Delegated core resources ─────────────────────────────────────────────
+    get apiKey() { return this.core.apiKey; }
+    get campaign() { return this.core.campaign; }
+    get claim() { return this.core.claim; }
+    get currency() { return this.core.currency; }
+    get customer() { return this.core.customer; }
+    get customerGroup() { return this.core.customerGroup; }
+    get draftOrder() { return this.core.draftOrder; }
+    get exchange() { return this.core.exchange; }
+    get fulfillment() { return this.core.fulfillment; }
+    get fulfillmentProvider() { return this.core.fulfillmentProvider; }
+    get fulfillmentSet() { return this.core.fulfillmentSet; }
+    get inventoryItem() { return this.core.inventoryItem; }
+    get invite() { return this.core.invite; }
+    get locale() { return this.core.locale; }
+    get notification() { return this.core.notification; }
+    get order() { return this.core.order; }
+    get orderEdit() { return this.core.orderEdit; }
+    get payment() { return this.core.payment; }
+    get paymentCollection() { return this.core.paymentCollection; }
+    get plugin() { return this.core.plugin; }
+    get priceList() { return this.core.priceList; }
+    get pricePreference() { return this.core.pricePreference; }
+    get product() { return this.core.product; }
+    get productCategory() { return this.core.productCategory; }
+    get productCollection() { return this.core.productCollection; }
+    get productTag() { return this.core.productTag; }
+    get productType() { return this.core.productType; }
+    get productVariant() { return this.core.productVariant; }
+    get promotion() { return this.core.promotion; }
+    get refundReason() { return this.core.refundReason; }
+    get region() { return this.core.region; }
+    get reservation() { return this.core.reservation; }
+    get return() { return this.core.return; }
+    get returnReason() { return this.core.returnReason; }
+    get salesChannel() { return this.core.salesChannel; }
+    get shippingOption() { return this.core.shippingOption; }
+    get shippingOptionType() { return this.core.shippingOptionType; }
+    get shippingProfile() { return this.core.shippingProfile; }
+    get stockLocation() { return this.core.stockLocation; }
+    get store() { return this.core.store; }
+    get taxProvider() { return this.core.taxProvider; }
+    get taxRate() { return this.core.taxRate; }
+    get taxRegion() { return this.core.taxRegion; }
+    get translation() { return this.core.translation; }
+    get upload() { return this.core.upload; }
+    get user() { return this.core.user; }
+    get views() { return this.core.views; }
+    get workflowExecution() { return this.core.workflowExecution; }
+}

package/dist/analytics.d.ts

@@ -0,0 +1,37 @@
+import type { Client } from '@medusajs/js-sdk';
+import type { AnalyticsConfig, TrackOptions } from './types/analytics';
+export declare class Analytics {
+    private client;
+    private salesChannelId?;
+    private cartId?;
+    private batchSize;
+    private flushIntervalMs;
+    private isBrowser;
+    private queue;
+    private timer;
+    private flushing;
+    constructor(client: Client, config?: AnalyticsConfig);
+    /**
+     * Track an analytics event.
+     *
+     * Browser: queues the event and flushes when batch is full or on interval.
+     * Server: sends immediately.
+     */
+    track(event: string, options?: TrackOptions): void;
+    /**
+     * Identify an actor. Sends a special `_identify` event that the backend
+     * routes to `analyticsService.identify()`.
+     */
+    identify(actorId: string, properties?: Record<string, unknown>): void;
+    /** Update the default actor ID (typically when cart is created/loaded). */
+    setCartId(cartId: string): void;
+    /** Update the default sales channel ID. */
+    setSalesChannelId(salesChannelId: string): void;
+    /** Flush all queued events immediately. */
+    flush(): Promise<void>;
+    /** Stop the flush timer and flush remaining events. Call on cleanup. */
+    destroy(): Promise<void>;
+    private send;
+    private startFlushTimer;
+    private bindUnloadHandler;
+}

package/dist/analytics.js

@@ -0,0 +1,131 @@
+// Source: packages/mildred/src/api/validators.ts
+// Routes: POST /store/ping
+const ENDPOINT = '/store/ping';
+export class Analytics {
+    constructor(client, config) {
+        this.queue = [];
+        this.timer = null;
+        this.flushing = false;
+        this.client = client;
+        this.salesChannelId = config?.salesChannelId;
+        this.cartId = config?.cartId;
+        this.batchSize = config?.batchSize ?? 10;
+        this.flushIntervalMs = config?.flushInterval ?? 2000;
+        this.isBrowser = typeof window !== 'undefined';
+        if (this.isBrowser) {
+            this.startFlushTimer();
+            this.bindUnloadHandler();
+        }
+    }
+    /**
+     * Track an analytics event.
+     *
+     * Browser: queues the event and flushes when batch is full or on interval.
+     * Server: sends immediately.
+     */
+    track(event, options) {
+        const payload = {
+            event,
+            actor_id: options?.cartId ?? this.cartId,
+            session_id: options?.sessionId,
+            properties: options?.properties,
+            sales_channel_id: options?.salesChannelId ?? this.salesChannelId
+        };
+        if (this.isBrowser) {
+            this.queue.push(payload);
+            if (this.queue.length >= this.batchSize) {
+                void this.flush();
+            }
+        }
+        else {
+            void this.send(payload);
+        }
+    }
+    /**
+     * Identify an actor. Sends a special `_identify` event that the backend
+     * routes to `analyticsService.identify()`.
+     */
+    identify(actorId, properties) {
+        const payload = {
+            event: '_identify',
+            actor_id: actorId,
+            properties: {
+                ...properties,
+                anonymous_id: this.cartId
+            },
+            sales_channel_id: this.salesChannelId
+        };
+        if (this.isBrowser) {
+            this.queue.push(payload);
+            void this.flush();
+        }
+        else {
+            void this.send(payload);
+        }
+    }
+    /** Update the default actor ID (typically when cart is created/loaded). */
+    setCartId(cartId) {
+        this.cartId = cartId;
+    }
+    /** Update the default sales channel ID. */
+    setSalesChannelId(salesChannelId) {
+        this.salesChannelId = salesChannelId;
+    }
+    /** Flush all queued events immediately. */
+    async flush() {
+        if (this.flushing || this.queue.length === 0)
+            return;
+        this.flushing = true;
+        const batch = this.queue.splice(0);
+        try {
+            await Promise.all(batch.map(event => this.send(event)));
+        }
+        catch {
+            this.queue.unshift(...batch);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    /** Stop the flush timer and flush remaining events. Call on cleanup. */
+    async destroy() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        await this.flush();
+    }
+    async send(payload) {
+        await this.client.fetch(ENDPOINT, {
+            method: 'POST',
+            body: payload
+        });
+    }
+    startFlushTimer() {
+        this.timer = setInterval(() => {
+            void this.flush();
+        }, this.flushIntervalMs);
+    }
+    bindUnloadHandler() {
+        if (typeof document === 'undefined')
+            return;
+        const onUnload = () => {
+            if (this.queue.length === 0)
+                return;
+            if (typeof navigator?.sendBeacon === 'function') {
+                const batch = this.queue.splice(0);
+                for (const event of batch) {
+                    const blob = new Blob([JSON.stringify(event)], {
+                        type: 'application/json'
+                    });
+                    navigator.sendBeacon(ENDPOINT, blob);
+                }
+            }
+        };
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'hidden') {
+                onUnload();
+            }
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+import { Client, Auth } from '@medusajs/js-sdk';
+import type { Config } from '@medusajs/js-sdk';
+import { Store } from './store';
+import { Admin } from './admin';
+import { Analytics } from './analytics';
+import type { AnalyticsConfig } from './types/analytics';
+export interface MedusaConfig extends Config {
+    /** Analytics configuration (batching, flush interval, etc.) */
+    analytics?: AnalyticsConfig;
+}
+export default class Medusa {
+    client: Client;
+    store: Store;
+    admin: Admin;
+    auth: Auth;
+    analytics: Analytics;
+    constructor(config: MedusaConfig);
+    setLocale(locale: string): void;
+    getLocale(): string;
+}
+export { Store } from './store';
+export { Admin } from './admin';
+export { Analytics } from './analytics';
+export { Client, Auth, FetchError } from '@medusajs/js-sdk';
+export type { Config, ClientHeaders, FetchArgs, FetchInput, FetchStreamResponse, Logger } from '@medusajs/js-sdk';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,25 @@
+import { Client, Auth } from '@medusajs/js-sdk';
+import { Store } from './store';
+import { Admin } from './admin';
+import { Analytics } from './analytics';
+export default class Medusa {
+    constructor(config) {
+        this.client = new Client(config);
+        this.store = new Store(this.client);
+        this.admin = new Admin(this.client);
+        this.auth = new Auth(this.client, config);
+        this.analytics = new Analytics(this.client, config.analytics);
+    }
+    setLocale(locale) {
+        this.client.setLocale(locale);
+    }
+    getLocale() {
+        return this.client.locale;
+    }
+}
+// Re-export types for consumers
+export { Store } from './store';
+export { Admin } from './admin';
+export { Analytics } from './analytics';
+export { Client, Auth, FetchError } from '@medusajs/js-sdk';
+export * from './types';

package/dist/resources/admin/review.d.ts

@@ -0,0 +1,11 @@
+import type { Client, ClientHeaders } from '@medusajs/js-sdk';
+import type { AdminReviewListQuery, AdminReviewListResponse, AdminReviewResponse, AdminReviewDeleteResponse, AdminReviewBatchResponse, AdminUpdateReviewInput } from '../../types/review';
+export declare function createAdminReviewResource(client: Client): {
+    list: (query?: AdminReviewListQuery, headers?: ClientHeaders) => Promise<AdminReviewListResponse>;
+    retrieve: (id: string, query?: Record<string, unknown>, headers?: ClientHeaders) => Promise<AdminReviewResponse>;
+    update: (id: string, body: AdminUpdateReviewInput, headers?: ClientHeaders) => Promise<AdminReviewResponse>;
+    delete: (id: string, headers?: ClientHeaders) => Promise<AdminReviewDeleteResponse>;
+    batchDelete: (ids: string[], headers?: ClientHeaders) => Promise<AdminReviewBatchResponse>;
+    approve: (ids: string[], headers?: ClientHeaders) => Promise<AdminReviewBatchResponse>;
+    reject: (ids: string[], headers?: ClientHeaders) => Promise<AdminReviewBatchResponse>;
+};

package/dist/resources/admin/review.js

@@ -0,0 +1,27 @@
+// Source: packages/reviews/src/api/admin/ + packages/reviews/src/api/validators.ts
+// Routes: GET/POST/DELETE /admin/reviews, POST /admin/reviews/approve, POST /admin/reviews/reject
+export function createAdminReviewResource(client) {
+    return {
+        list: async (query, headers) => {
+            return client.fetch(`/admin/reviews`, { query, headers });
+        },
+        retrieve: async (id, query, headers) => {
+            return client.fetch(`/admin/reviews/${id}`, { query, headers });
+        },
+        update: async (id, body, headers) => {
+            return client.fetch(`/admin/reviews/${id}`, { method: 'POST', body, headers });
+        },
+        delete: async (id, headers) => {
+            return client.fetch(`/admin/reviews/${id}`, { method: 'DELETE', headers });
+        },
+        batchDelete: async (ids, headers) => {
+            return client.fetch(`/admin/reviews`, { method: 'DELETE', body: { ids }, headers });
+        },
+        approve: async (ids, headers) => {
+            return client.fetch(`/admin/reviews/approve`, { method: 'POST', body: { ids }, headers });
+        },
+        reject: async (ids, headers) => {
+            return client.fetch(`/admin/reviews/reject`, { method: 'POST', body: { ids }, headers });
+        },
+    };
+}

package/dist/resources/store/content.d.ts

@@ -0,0 +1,8 @@
+import type { Client, ClientHeaders } from '@medusajs/js-sdk';
+import type { StoreContentListQuery, StoreContentCollectionListResponse, StoreContentCollectionResponse, StoreContentItemListQuery, StoreContentItemListResponse, StoreContentItemResponse } from '../../types/content';
+export declare function createStoreContentResource(client: Client): {
+    list: (query?: StoreContentListQuery, headers?: ClientHeaders) => Promise<StoreContentCollectionListResponse>;
+    retrieve: (slug: string, query?: StoreContentListQuery, headers?: ClientHeaders) => Promise<StoreContentCollectionResponse>;
+    listItems: (slug: string, query?: StoreContentItemListQuery, headers?: ClientHeaders) => Promise<StoreContentItemListResponse>;
+    retrieveItem: (slug: string, itemSlug: string, query?: StoreContentListQuery, headers?: ClientHeaders) => Promise<StoreContentItemResponse>;
+};

package/dist/resources/store/content.js

@@ -0,0 +1,18 @@
+// Source: packages/content/src/api/store/ + packages/content/src/api/validators.ts
+// Routes: GET /content, GET /content/:slug, GET /content/:slug/items, GET /content/:slug/items/:itemSlug
+export function createStoreContentResource(client) {
+    return {
+        list: async (query, headers) => {
+            return client.fetch(`/content`, { query, headers });
+        },
+        retrieve: async (slug, query, headers) => {
+            return client.fetch(`/content/${slug}`, { query, headers });
+        },
+        listItems: async (slug, query, headers) => {
+            return client.fetch(`/content/${slug}/items`, { query, headers });
+        },
+        retrieveItem: async (slug, itemSlug, query, headers) => {
+            return client.fetch(`/content/${slug}/items/${itemSlug}`, { query, headers });
+        },
+    };
+}

package/dist/resources/store/form.d.ts

@@ -0,0 +1,5 @@
+import type { Client, ClientHeaders } from '@medusajs/js-sdk';
+import type { FormSubmitInput, FormSubmitResponse } from '../../types/form';
+export declare function createStoreFormResource(client: Client): {
+    submit: (handle: string, body: FormSubmitInput, headers?: ClientHeaders) => Promise<FormSubmitResponse>;
+};

package/dist/resources/store/form.js

@@ -0,0 +1,9 @@
+// Source: packages/forms/src/api/ + packages/forms/src/api/validators.ts
+// Routes: POST /forms/:handle
+export function createStoreFormResource(client) {
+    return {
+        submit: async (handle, body, headers) => {
+            return client.fetch(`/forms/${handle}`, { method: 'POST', body, headers });
+        },
+    };
+}

package/dist/resources/store/review.d.ts

@@ -0,0 +1,6 @@
+import type { Client, ClientHeaders } from '@medusajs/js-sdk';
+import type { StoreCreateReviewInput, StoreReviewListResponse, StoreReviewResponse } from '../../types/review';
+export declare function createStoreReviewResource(client: Client): {
+    list: (productId: string, query?: Record<string, unknown>, headers?: ClientHeaders) => Promise<StoreReviewListResponse>;
+    create: (productId: string, body: StoreCreateReviewInput, headers?: ClientHeaders) => Promise<StoreReviewResponse>;
+};

package/dist/resources/store/review.js

@@ -0,0 +1,12 @@
+// Source: packages/reviews/src/api/store/ + packages/reviews/src/api/validators.ts
+// Routes: GET/POST /store/reviews/:productId
+export function createStoreReviewResource(client) {
+    return {
+        list: async (productId, query, headers) => {
+            return client.fetch(`/store/reviews/${productId}`, { query, headers });
+        },
+        create: async (productId, body, headers) => {
+            return client.fetch(`/store/reviews/${productId}`, { method: 'POST', body, headers });
+        },
+    };
+}

package/dist/store.d.ts

@@ -0,0 +1,30 @@
+import { Client, Store as MedusaStore } from '@medusajs/js-sdk';
+import type { ClientHeaders } from '@medusajs/js-sdk';
+import type { HttpTypes, SelectParams } from '@medusajs/types';
+import { createStoreReviewResource } from './resources/store/review';
+import { createStoreContentResource } from './resources/store/content';
+import { createStoreFormResource } from './resources/store/form';
+import type { StoreProductListResponse, StoreProductResponse } from './types/expanded';
+type CoreStore = InstanceType<typeof MedusaStore>;
+export declare class Store {
+    private core;
+    private client;
+    review: ReturnType<typeof createStoreReviewResource>;
+    content: ReturnType<typeof createStoreContentResource>;
+    form: ReturnType<typeof createStoreFormResource>;
+    constructor(client: Client);
+    product: {
+        list: (query?: HttpTypes.StoreProductListParams, headers?: ClientHeaders) => Promise<StoreProductListResponse>;
+        retrieve: (id: string, query?: SelectParams, headers?: ClientHeaders) => Promise<StoreProductResponse>;
+    };
+    get region(): CoreStore['region'];
+    get collection(): CoreStore['collection'];
+    get category(): CoreStore['category'];
+    get cart(): CoreStore['cart'];
+    get order(): CoreStore['order'];
+    get customer(): CoreStore['customer'];
+    get fulfillment(): CoreStore['fulfillment'];
+    get payment(): CoreStore['payment'];
+    get locale(): CoreStore['locale'];
+}
+export {};

package/dist/store.js

@@ -0,0 +1,32 @@
+import { Store as MedusaStore } from '@medusajs/js-sdk';
+import { createStoreReviewResource } from './resources/store/review';
+import { createStoreContentResource } from './resources/store/content';
+import { createStoreFormResource } from './resources/store/form';
+export class Store {
+    constructor(client) {
+        // ── Overridden resources (expanded types) ────────────────────────────────
+        this.product = {
+            list: async (query, headers) => {
+                return this.client.fetch(`/store/products`, { query, headers });
+            },
+            retrieve: async (id, query, headers) => {
+                return this.client.fetch(`/store/products/${id}`, { query, headers });
+            },
+        };
+        this.client = client;
+        this.core = new MedusaStore(client);
+        this.review = createStoreReviewResource(client);
+        this.content = createStoreContentResource(client);
+        this.form = createStoreFormResource(client);
+    }
+    // ── Delegated core resources ─────────────────────────────────────────────
+    get region() { return this.core.region; }
+    get collection() { return this.core.collection; }
+    get category() { return this.core.category; }
+    get cart() { return this.core.cart; }
+    get order() { return this.core.order; }
+    get customer() { return this.core.customer; }
+    get fulfillment() { return this.core.fulfillment; }
+    get payment() { return this.core.payment; }
+    get locale() { return this.core.locale; }
+}

package/dist/types/analytics.d.ts

@@ -0,0 +1,27 @@
+export interface AnalyticsConfig {
+    /** Default sales channel ID attached to all events */
+    salesChannelId?: string;
+    /** Default actor ID (typically cart ID from cookie) */
+    cartId?: string;
+    /** Client-side only: flush when batch reaches this size (default: 10) */
+    batchSize?: number;
+    /** Client-side only: flush interval in ms (default: 2000) */
+    flushInterval?: number;
+}
+export interface TrackOptions {
+    /** Actor ID for this event (overrides default cartId) */
+    cartId?: string;
+    /** Event properties */
+    properties?: Record<string, unknown>;
+    /** Session ID */
+    sessionId?: string;
+    /** Sales channel ID (overrides default) */
+    salesChannelId?: string;
+}
+export interface AnalyticsEvent {
+    event: string;
+    actor_id?: string;
+    session_id?: string;
+    properties?: Record<string, unknown>;
+    sales_channel_id?: string;
+}

package/dist/types/analytics.js

@@ -0,0 +1,3 @@
+// Source: packages/mildred/src/api/validators.ts
+// Routes: POST /store/ping
+export {};

package/dist/types/content.d.ts

@@ -0,0 +1,78 @@
+export interface ContentCollection {
+    id: string;
+    label: string;
+    slug: string;
+    format: string;
+    prefix?: string;
+    metadata?: Record<string, unknown>;
+    content_fields?: ContentField[];
+    created_at: string;
+    updated_at: string;
+}
+export interface ContentField {
+    id: string;
+    name: string;
+    label: string;
+    field_type: string;
+    required?: boolean;
+    options?: string;
+    default_value?: string;
+    sort_order?: number;
+}
+export interface ContentItem {
+    id: string;
+    title: string;
+    slug: string;
+    body?: string;
+    format?: string;
+    status: string;
+    published_at?: string;
+    metadata?: Record<string, unknown>;
+    content_collection?: Pick<ContentCollection, 'id' | 'label' | 'slug' | 'format'>;
+    creator?: ContentCreator;
+    tags?: ContentTag[];
+    created_at: string;
+    updated_at?: string;
+}
+export interface ContentCreator {
+    id: string;
+    name: string;
+    bio?: string;
+    avatar_url?: string;
+}
+export interface ContentTag {
+    id: string;
+    value: string;
+    metadata?: Record<string, unknown>;
+}
+export interface StoreContentListQuery {
+    q?: string;
+    limit?: number;
+    offset?: number;
+    fields?: string;
+}
+export interface StoreContentCollectionListResponse {
+    content_collections: ContentCollection[];
+    count: number;
+    limit: number;
+    offset: number;
+}
+export interface StoreContentCollectionResponse {
+    content_collection: ContentCollection;
+}
+export interface StoreContentItemListQuery {
+    tag?: string;
+    q?: string;
+    limit?: number;
+    offset?: number;
+    fields?: string;
+}
+export interface StoreContentItemListResponse {
+    content_items: ContentItem[];
+    count: number;
+    limit: number;
+    offset: number;
+}
+export interface StoreContentItemResponse {
+    content_item: ContentItem;
+}

package/dist/types/content.js

@@ -0,0 +1,3 @@
+// Source: packages/content/src/api/validators.ts
+// Routes: GET /content, GET /content/:slug, GET /content/:slug/items, GET /content/:slug/items/:itemSlug
+export {};

package/dist/types/expanded.d.ts

@@ -0,0 +1,30 @@
+import type { HttpTypes } from '@medusajs/types';
+import type { Review } from './review';
+export interface StoreProduct extends HttpTypes.StoreProduct {
+    reviews?: Review[];
+    review_stats?: {
+        average_rating: number;
+        count: number;
+    };
+}
+export interface StoreProductListResponse {
+    products: StoreProduct[];
+    count: number;
+    offset: number;
+    limit: number;
+}
+export interface StoreProductResponse {
+    product: StoreProduct;
+}
+export interface AdminProduct extends HttpTypes.AdminProduct {
+    reviews?: Review[];
+}
+export interface AdminProductListResponse {
+    products: AdminProduct[];
+    count: number;
+    offset: number;
+    limit: number;
+}
+export interface AdminProductResponse {
+    product: AdminProduct;
+}

package/dist/types/expanded.js

@@ -0,0 +1 @@
+export {};

package/dist/types/form.d.ts

@@ -0,0 +1,7 @@
+export interface FormSubmitInput {
+    cf_turnstile_response?: string;
+    data: Record<string, unknown>;
+}
+export interface FormSubmitResponse {
+    submitted: boolean;
+}

package/dist/types/form.js

@@ -0,0 +1,3 @@
+// Source: packages/forms/src/api/validators.ts
+// Routes: POST /forms/:handle
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './review';
+export * from './content';
+export * from './form';
+export * from './analytics';
+export * from './expanded';

package/dist/types/index.js

@@ -0,0 +1,5 @@
+export * from './review';
+export * from './content';
+export * from './form';
+export * from './analytics';
+export * from './expanded';

package/dist/types/review.d.ts

@@ -0,0 +1,66 @@
+export interface Review {
+    id: string;
+    status: 'pending' | 'approved' | 'rejected';
+    rating: number;
+    title?: string;
+    body: string;
+    author_name: string;
+    author_email?: string;
+    product_id: string;
+    order_id?: string;
+    customer_id?: string;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface StoreCreateReviewInput {
+    rating: number;
+    title?: string;
+    body: string;
+    author_name: string;
+    author_email?: string;
+    order_id?: string;
+}
+export interface StoreReviewListResponse {
+    reviews: Review[];
+    count: number;
+    limit: number;
+    offset: number;
+}
+export interface StoreReviewResponse {
+    review: Review;
+}
+export interface AdminReviewListQuery {
+    q?: string;
+    status?: 'pending' | 'approved' | 'rejected';
+    product_id?: string;
+    customer_id?: string;
+    limit?: number;
+    offset?: number;
+    order?: string;
+    fields?: string;
+}
+export interface AdminUpdateReviewInput {
+    status?: 'pending' | 'approved' | 'rejected';
+    title?: string;
+    body?: string;
+    rating?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface AdminReviewListResponse {
+    reviews: Review[];
+    count: number;
+    limit: number;
+    offset: number;
+}
+export interface AdminReviewResponse {
+    review: Review;
+}
+export interface AdminReviewDeleteResponse {
+    id: string;
+    object: string;
+    deleted: boolean;
+}
+export interface AdminReviewBatchResponse {
+    ids: string[];
+}

package/dist/types/review.js

@@ -0,0 +1,3 @@
+// Source: packages/reviews/src/api/validators.ts
+// Routes: GET/POST /store/reviews/:productId, GET/POST/DELETE /admin/reviews
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@pevey/medusa",
+	"version": "2.14.2",
+	"description": "Extended Medusa JS SDK with custom plugin support",
+	"author": "Lacey Pevey",
+	"license": "MIT",
+	"type": "module",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"prepublishOnly": "tsc"
+	},
+	"dependencies": {
+		"@medusajs/js-sdk": "2.14.2",
+		"@medusajs/types": "2.14.2"
+	},
+	"devDependencies": {
+		"typescript": "5.6.2"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"gitHead": "35f16164d0d17e6281b2801a9f1eb355b5035571"
+}