@lasterp/shared 1.0.0-alpha.0

package/src/client/core.ts

@@ -0,0 +1,261 @@
+import { camelizeKeys, decamelizeKeys } from 'humps';
+import type { FrappeResponse, FrappeError, AuthOptions } from './types';
+
+async function request<T = any>(
+  baseUrl: string,
+  endpoint: string,
+  options: RequestInit = {},
+  auth?: AuthOptions
+): Promise<T> {
+  const url = `${baseUrl}${endpoint}`;
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+    ...(options.headers as Record<string, string>),
+  };
+
+  if (auth?.token) {
+    headers['Authorization'] = `Bearer ${auth.token}`;
+  } else if (auth?.apiKey) {
+    headers['Authorization'] = `token ${auth.apiKey.key}:${auth.apiKey.secret}`;
+  }
+
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    credentials: 'include',
+  });
+
+  const rawData: FrappeResponse<any> = await response.json();
+
+  if (!response.ok || rawData.exc) {
+    // Create a proper Error object for better serialization in Next.js
+    const errorMessage = rawData._error_message || rawData.exc || 'Request failed';
+    const error = new Error(errorMessage) as Error & FrappeError;
+
+    error.message = errorMessage;
+    error.statusCode = response.status;
+
+    if (rawData.exc) {
+      error.exc = rawData.exc;
+    }
+
+    if (rawData._server_messages) {
+      error.serverMessages = rawData._server_messages;
+    }
+
+    if (rawData.exc_type) {
+      error.excType = rawData.exc_type;
+    }
+
+    throw error;
+  }
+
+  const result = rawData.message ?? rawData;
+  return camelizeKeys(result) as T;
+}
+
+export async function frappeCall<T = any>(
+  baseUrl: string,
+  method: string,
+  args?: Record<string, any>,
+  auth?: AuthOptions
+): Promise<T> {
+  const snakeArgs = decamelizeKeys(args ?? {});
+
+  return request<T>(
+    baseUrl,
+    `/api/method/${method}`,
+    {
+      method: 'POST',
+      body: JSON.stringify(snakeArgs),
+    },
+    auth
+  );
+}
+
+export async function frappeCallGet<T = any>(
+  baseUrl: string,
+  method: string,
+  args?: Record<string, any>,
+  auth?: AuthOptions
+): Promise<T> {
+  const snakeArgs = decamelizeKeys(args ?? {});
+  const queryParams = new URLSearchParams();
+
+  Object.entries(snakeArgs).forEach(([key, value]) => {
+    queryParams.append(
+      key,
+      typeof value === 'string' ? value : JSON.stringify(value)
+    );
+  });
+
+  const endpoint = `/api/method/${method}?${queryParams.toString()}`;
+  return request<T>(baseUrl, endpoint, { method: 'GET' }, auth);
+}
+
+export async function getList<T = any>(
+  baseUrl: string,
+  params: {
+    doctype: string;
+    fields?: string[];
+    filters?: Record<string, any>;
+    orderBy?: string;
+    limitStart?: number;
+    limitPageLength?: number;
+  },
+  auth?: AuthOptions
+): Promise<T[]> {
+  const {
+    doctype,
+    fields = ['name'],
+    filters = {},
+    orderBy = 'modified desc',
+    limitStart = 0,
+    limitPageLength = 20,
+  } = params;
+
+  const snakeFilters = decamelizeKeys(filters);
+
+  const queryParams = new URLSearchParams({
+    fields: JSON.stringify(fields),
+    filters: JSON.stringify(snakeFilters),
+    order_by: orderBy,
+    limit_start: limitStart.toString(),
+    limit_page_length: limitPageLength.toString(),
+  });
+
+  const endpoint = `/api/resource/${doctype}?${queryParams.toString()}`;
+  const response = await request<{ data: T[] }>(baseUrl, endpoint, {}, auth);
+  return response.data || [];
+}
+
+export async function getDoc<T = any>(
+  baseUrl: string,
+  doctype: string,
+  name: string,
+  auth?: AuthOptions
+): Promise<T> {
+  const endpoint = `/api/resource/${doctype}/${encodeURIComponent(name)}`;
+  const response = await request<{ data: T }>(baseUrl, endpoint, {}, auth);
+  return response.data;
+}
+
+export async function createDoc<T = any>(
+  baseUrl: string,
+  doctype: string,
+  doc: Record<string, any>,
+  auth?: AuthOptions
+): Promise<T> {
+  const snakeDoc = decamelizeKeys(doc);
+  const endpoint = `/api/resource/${doctype}`;
+  const response = await request<{ data: T }>(
+    baseUrl,
+    endpoint,
+    {
+      method: 'POST',
+      body: JSON.stringify(snakeDoc),
+    },
+    auth
+  );
+  return response.data;
+}
+
+export async function updateDoc<T = any>(
+  baseUrl: string,
+  doctype: string,
+  name: string,
+  doc: Record<string, any>,
+  auth?: AuthOptions
+): Promise<T> {
+  const snakeDoc = decamelizeKeys(doc);
+  const endpoint = `/api/resource/${doctype}/${encodeURIComponent(name)}`;
+  const response = await request<{ data: T }>(
+    baseUrl,
+    endpoint,
+    {
+      method: 'PUT',
+      body: JSON.stringify(snakeDoc),
+    },
+    auth
+  );
+  return response.data;
+}
+
+export async function deleteDoc(
+  baseUrl: string,
+  doctype: string,
+  name: string,
+  auth?: AuthOptions
+): Promise<void> {
+  const endpoint = `/api/resource/${doctype}/${encodeURIComponent(name)}`;
+  await request(
+    baseUrl,
+    endpoint,
+    {
+      method: 'DELETE',
+    },
+    auth
+  );
+}
+
+export async function getValue<T = any>(
+  baseUrl: string,
+  doctype: string,
+  name: string,
+  fieldname: string,
+  auth?: AuthOptions
+): Promise<T> {
+  const endpoint = `/api/resource/${doctype}/${encodeURIComponent(name)}?fields=["${fieldname}"]`;
+  const response = await request<{ data: Record<string, T> }>(
+    baseUrl,
+    endpoint,
+    {},
+    auth
+  );
+  const value = response.data[fieldname];
+
+  if (value === undefined) {
+    throw new Error(
+      `Field "${fieldname}" not found in document "${doctype}/${name}"`
+    );
+  }
+
+  return value;
+}
+
+export async function setValue<T = any>(
+  baseUrl: string,
+  doctype: string,
+  name: string,
+  fieldname: string,
+  value: any,
+  auth?: AuthOptions
+): Promise<T> {
+  return updateDoc<T>(baseUrl, doctype, name, { [fieldname]: value }, auth);
+}
+
+export async function getCount(
+  baseUrl: string,
+  doctype: string,
+  filters: Record<string, any> = {},
+  auth?: AuthOptions
+): Promise<number> {
+  return frappeCall<number>(
+    baseUrl,
+    'frappe.client.get_count',
+    {
+      doctype,
+      filters,
+    },
+    auth
+  );
+}
+
+export async function getCurrentUser(
+  baseUrl: string,
+  auth?: AuthOptions
+): Promise<any> {
+  return frappeCallGet(baseUrl, 'frappe.auth.get_logged_user', {}, auth);
+}

package/src/client/hooks.tsx

@@ -0,0 +1,57 @@
+'use client';
+
+import { useFrappeConfig } from './context';
+import {
+  frappeCall as frappeCallCore,
+  frappeCallGet as frappeCallGetCore,
+  getDoc as getDocCore,
+  getList as getListCore,
+  createDoc as createDocCore,
+  updateDoc as updateDocCore,
+  deleteDoc as deleteDocCore,
+} from './core';
+import type { AuthOptions } from './types';
+
+export function useFrappe() {
+  const { baseUrl, token, apiKey } = useFrappeConfig();
+
+  const auth: AuthOptions = {
+    ...(token && { token }),
+    ...(apiKey && { apiKey }),
+  };
+
+  return {
+    call: <T = any>(method: string, args?: Record<string, any>) =>
+      frappeCallCore<T>(baseUrl, method, args, auth),
+
+    callGet: <T = any>(method: string, args?: Record<string, any>) =>
+      frappeCallGetCore<T>(baseUrl, method, args, auth),
+
+    getList: <T = any>(params: {
+      doctype: string;
+      fields?: string[];
+      filters?: Record<string, any>;
+      orderBy?: string;
+      limitStart?: number;
+      limitPageLength?: number;
+    }) => getListCore<T>(baseUrl, params, auth),
+
+    getDoc: <T = any>(doctype: string, name: string) =>
+      getDocCore<T>(baseUrl, doctype, name, auth),
+
+    createDoc: <T = any>(doctype: string, doc: Record<string, any>) =>
+      createDocCore<T>(baseUrl, doctype, doc, auth),
+
+    updateDoc: <T = any>(
+      doctype: string,
+      name: string,
+      doc: Record<string, any>
+    ) => updateDocCore<T>(baseUrl, doctype, name, doc, auth),
+
+    deleteDoc: (doctype: string, name: string) =>
+      deleteDocCore(baseUrl, doctype, name, auth),
+
+    baseUrl,
+    auth,
+  };
+}

package/src/client/index.ts

@@ -0,0 +1,21 @@
+export {
+  frappeCall,
+  frappeCallGet,
+  getList,
+  getDoc,
+  createDoc,
+  updateDoc,
+  deleteDoc,
+  getValue,
+  setValue,
+  getCount,
+  getCurrentUser,
+} from './core';
+
+export type { FrappeResponse, FrappeError, AuthOptions } from './types';
+
+export { FrappeProvider, useFrappeConfig } from './context';
+export type { FrappeContextValue, FrappeProviderProps } from './context';
+export { useFrappe } from './hooks';
+
+export * from './storage';

package/src/client/storage.ts

@@ -0,0 +1,76 @@
+export interface StorageAdapter {
+  getItem(key: string): string | null | Promise<string | null>;
+  setItem(key: string, value: string): void | Promise<void>;
+  removeItem(key: string): void | Promise<void>;
+}
+
+export const webStorageAdapter: StorageAdapter = {
+  getItem: (key: string) => {
+    if (typeof window === 'undefined') return null;
+    return localStorage.getItem(key);
+  },
+  setItem: (key: string, value: string) => {
+    if (typeof window === 'undefined') return;
+    localStorage.setItem(key, value);
+  },
+  removeItem: (key: string) => {
+    if (typeof window === 'undefined') return;
+    localStorage.removeItem(key);
+  },
+};
+
+let currentAdapter: StorageAdapter = webStorageAdapter;
+
+export function setStorageAdapter(adapter: StorageAdapter) {
+  currentAdapter = adapter;
+}
+
+export function getStorageAdapter(): StorageAdapter {
+  return currentAdapter;
+}
+
+const TOKEN_KEY = 'frappe_token';
+const API_KEY_KEY = 'frappe_api_key';
+const API_SECRET_KEY = 'frappe_api_secret';
+
+export function getToken(): string | null | Promise<string | null> {
+  return currentAdapter.getItem(TOKEN_KEY);
+}
+
+export function setToken(token: string): void | Promise<void> {
+  return currentAdapter.setItem(TOKEN_KEY, token);
+}
+
+export function clearToken(): void | Promise<void> {
+  return currentAdapter.removeItem(TOKEN_KEY);
+}
+
+export async function getApiKey(): Promise<{ key: string; secret: string } | null> {
+  const key = await currentAdapter.getItem(API_KEY_KEY);
+  const secret = await currentAdapter.getItem(API_SECRET_KEY);
+
+  if (!key || !secret) return null;
+
+  return { key, secret };
+}
+
+export async function setApiKey(key: string, secret: string): Promise<void> {
+  await currentAdapter.setItem(API_KEY_KEY, key);
+  await currentAdapter.setItem(API_SECRET_KEY, secret);
+}
+
+export async function clearApiKey(): Promise<void> {
+  await currentAdapter.removeItem(API_KEY_KEY);
+  await currentAdapter.removeItem(API_SECRET_KEY);
+}
+
+export async function clearAuth(): Promise<void> {
+  await clearToken();
+  await clearApiKey();
+}
+
+export async function isAuthenticated(): Promise<boolean> {
+  const token = await getToken();
+  const apiKey = await getApiKey();
+  return !!token || !!apiKey;
+}

package/src/client/types.ts

@@ -0,0 +1,24 @@
+export interface FrappeResponse<T = any> {
+  message?: T;
+  docs?: T[];
+  exc?: string;
+  exc_type?: string;
+  _server_messages?: string;
+  _error_message?: string;
+}
+
+export interface FrappeError {
+  message: string;
+  statusCode?: number;
+  exc?: string;
+  excType?: string;
+  serverMessages?: string;
+}
+
+export interface AuthOptions {
+  token?: string;
+  apiKey?: {
+    key: string;
+    secret: string;
+  };
+}

package/src/common/index.ts

@@ -0,0 +1 @@
+export type { FrappeDoc, FrappeChildDoc } from './types';

package/src/common/types.ts

@@ -0,0 +1,15 @@
+export interface FrappeDoc {
+  name: string;
+  creation?: string;
+  modified?: string;
+  modifiedBy?: string;
+  owner?: string;
+  docStatus?: number;
+  idx?: number;
+}
+
+export interface FrappeChildDoc extends FrappeDoc {
+  parent: string;
+  parentType: string;
+  parentField: string;
+}

package/src/design/block/types.ts

@@ -0,0 +1,8 @@
+export interface AaveFeatureSlidesData {
+  feature1Title: string
+  feature1Description: string
+  feature1Cta?: string
+  feature2Title: string
+  feature2Description: string
+  feature2Cta?: string
+}

package/src/design/globals/footer.ts

@@ -0,0 +1,20 @@
+
+export interface FooterItemGroup {
+  title: string;
+  items: FooterItem[];
+}
+
+export interface FooterItem {
+  label: string;
+  link?: string;
+}
+
+export interface Footer {
+  footerType?: string;
+  groups: FooterItemGroup[];
+  copyright?: string;
+  address?: string;
+  country?: string;
+  phone?: string;
+  email?: string;
+}

package/src/design/globals/header.ts

@@ -0,0 +1,43 @@
+export interface Brand {
+  brandImage?: string;
+}
+
+export interface NavbarItem {
+  label: string;
+  enableDropdown: boolean;
+  enableLink: boolean;
+  link?: string;
+  dropdownDescription?: string;
+  dropdownCta?: string;
+  groups?: NavbarSubItemGroup[]
+}
+
+export interface NavbarSubItemGroup {
+  title?: string;
+  items: NavbarSubItem[];
+}
+
+export interface NavbarSubItem {
+  label: string;
+  description?: string;
+  image?: string;
+  link?: string;
+}
+
+export interface Topbar {
+  topbarEnabled?: boolean;
+  items: TopbarItem[];
+}
+
+export interface TopbarItem {
+  icon?: string;
+  label: string;
+  link?: string;
+}
+
+export interface Header {
+  brand: Brand;
+  headerType?: string;
+  tabs: NavbarItem[];
+  topbar: Topbar;
+}

package/src/design/globals/types.ts

@@ -0,0 +1,7 @@
+import type {Header} from "./header";
+import type {Footer} from "./footer";
+
+export interface Globals {
+  header: Header
+  footer: Footer
+}

package/src/design/index.ts

@@ -0,0 +1,8 @@
+export * from './globals/types';
+export * from './globals/header';
+export * from './globals/footer';
+
+export * from './page/types';
+export * from './page/api';
+
+export * from './block/types';

package/src/design/page/api.ts

@@ -0,0 +1,11 @@
+import { getDoc } from '../../client'
+import type { AuthOptions } from '../../client'
+import type { Page } from './types'
+
+export async function getPage(
+  baseUrl: string,
+  slug: string,
+  auth?: AuthOptions
+): Promise<Page> {
+  return getDoc<Page>(baseUrl, 'Design Page', slug, auth)
+}

package/src/design/page/types.ts

@@ -0,0 +1,15 @@
+export interface Hero {
+  type: string;
+  data: Record<string, unknown>;
+}
+
+export interface Block {
+  type: string;
+  data?: Record<string, unknown>;
+}
+
+export interface Page {
+  slug: string;
+  hero?: Hero;
+  blocks: Block[];
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './common'
+export * from './client'
+export * from './design'
+export * from './utils'
+export * from './lasterp'

package/src/lasterp/catalog/types.ts

@@ -0,0 +1,24 @@
+export interface Item {
+  itemCode: string
+  region: string
+  grade: string
+  gradeIssuer: string
+  color: string
+  storage: string
+  memory: string
+  network: string
+}
+
+export interface ItemVariant extends Item {
+  itemVariant: string
+}
+
+export interface ModelNumber {
+  modelNumber: string
+  simCardType: string
+}
+
+export interface Colour {
+  name: string
+  color: string
+}

package/src/lasterp/index.ts

@@ -0,0 +1,5 @@
+export * from './catalog/types';
+
+export * from './shop/types';
+export * from './shop/api';
+export * from './shop/hooks';

package/src/lasterp/shop/api.ts

@@ -0,0 +1,32 @@
+import { frappeCall } from '../../client';
+import type { AuthOptions } from '../../client';
+import type { ShopContext, ProductContext } from './types';
+
+export async function getShopContext(
+  baseUrl: string,
+  params?: {
+    categoryName?: string;
+    gradeName?: string;
+  },
+  auth?: AuthOptions
+): Promise<ShopContext> {
+  return frappeCall<ShopContext>(
+    baseUrl,
+    'lasterp.shop.controllers.shop_controller.get_context',
+    params,
+    auth
+  );
+}
+
+export async function getProductContext(
+  baseUrl: string,
+  productName: string,
+  auth?: AuthOptions
+): Promise<ProductContext> {
+  return frappeCall<ProductContext>(
+    baseUrl,
+    'lasterp.shop.controllers.product_controller.get_context',
+    { productName },
+    auth
+  );
+}

package/src/lasterp/shop/hooks.tsx

@@ -0,0 +1,42 @@
+'use client';
+
+import { useQuery, type UseQueryOptions } from '@tanstack/react-query';
+import { useFrappe } from '../../client';
+import { getShopContext, getProductContext } from './api';
+import type { ShopContext, ProductContext } from './types';
+
+export function useShopContext(
+  params?: {
+    categoryName?: string;
+    gradeName?: string;
+  },
+  options?: Omit<
+    UseQueryOptions<ShopContext, Error>,
+    'queryKey' | 'queryFn'
+  >
+) {
+  const { baseUrl, auth } = useFrappe();
+
+  return useQuery<ShopContext, Error>({
+    queryKey: ['shop-context', params],
+    queryFn: () => getShopContext(baseUrl, params, auth),
+    ...options,
+  });
+}
+
+export function useProductContext(
+  productName: string,
+  options?: Omit<
+    UseQueryOptions<ProductContext, Error>,
+    'queryKey' | 'queryFn'
+  >
+) {
+  const { baseUrl, auth } = useFrappe();
+
+  return useQuery<ProductContext, Error>({
+    queryKey: ['product-context', productName],
+    queryFn: () => getProductContext(baseUrl, productName, auth),
+    enabled: !!productName,
+    ...options,
+  });
+}