veryfront 0.0.48 → 0.0.50

package/dist/integrations/shopify/files/ai/tools/list-orders.ts

@@ -0,0 +1,52 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listOrders } from "../../lib/shopify-client.ts";
+
+export default tool({
+  id: "list-orders",
+  description:
+    "List orders from your Shopify store. Can filter by status, financial status, and fulfillment status.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(250).default(20).describe("Maximum number of orders to return"),
+    status: z.enum(["open", "closed", "cancelled", "any"]).optional().describe("Filter by order status"),
+    financialStatus: z.enum(["pending", "authorized", "paid", "refunded", "voided"]).optional().describe("Filter by financial status"),
+    fulfillmentStatus: z.enum(["shipped", "partial", "unshipped", "any", "unfulfilled"]).optional().describe("Filter by fulfillment status"),
+  }),
+  async execute({ limit, status, financialStatus, fulfillmentStatus }) {
+    const orders = await listOrders({ limit, status, financialStatus, fulfillmentStatus });
+
+    return orders.map((order) => ({
+      id: order.id,
+      orderNumber: order.order_number,
+      email: order.email,
+      createdAt: order.created_at,
+      totalPrice: order.total_price,
+      subtotalPrice: order.subtotal_price,
+      totalTax: order.total_tax,
+      currency: order.currency,
+      financialStatus: order.financial_status,
+      fulfillmentStatus: order.fulfillment_status,
+      customer: order.customer ? {
+        id: order.customer.id,
+        email: order.customer.email,
+        firstName: order.customer.first_name,
+        lastName: order.customer.last_name,
+      } : null,
+      lineItems: order.line_items.map((item) => ({
+        id: item.id,
+        title: item.title,
+        quantity: item.quantity,
+        price: item.price,
+        sku: item.sku,
+        variantTitle: item.variant_title,
+      })),
+      shippingAddress: order.shipping_address ? {
+        address1: order.shipping_address.address1,
+        city: order.shipping_address.city,
+        province: order.shipping_address.province,
+        country: order.shipping_address.country,
+        zip: order.shipping_address.zip,
+      } : null,
+    }));
+  },
+});

package/dist/integrations/shopify/files/ai/tools/list-products.ts

@@ -0,0 +1,39 @@
+import { tool } from "veryfront/ai";
+import { z } from "zod";
+import { listProducts } from "../../lib/shopify-client.ts";
+
+export default tool({
+  id: "list-products",
+  description:
+    "List products from your Shopify store. Can filter by status and product type.",
+  inputSchema: z.object({
+    limit: z.number().min(1).max(250).default(20).describe("Maximum number of products to return"),
+    status: z.enum(["active", "archived", "draft"]).optional().describe("Filter by product status"),
+    productType: z.string().optional().describe("Filter by product type"),
+  }),
+  async execute({ limit, status, productType }) {
+    const products = await listProducts({ limit, status, productType });
+
+    return products.map((product) => ({
+      id: product.id,
+      title: product.title,
+      vendor: product.vendor,
+      productType: product.product_type,
+      status: product.status,
+      tags: product.tags,
+      createdAt: product.created_at,
+      variants: product.variants.map((v) => ({
+        id: v.id,
+        title: v.title,
+        price: v.price,
+        sku: v.sku,
+        inventoryQuantity: v.inventory_quantity,
+      })),
+      images: product.images.map((img) => ({
+        id: img.id,
+        src: img.src,
+        alt: img.alt,
+      })),
+    }));
+  },
+});

package/dist/integrations/shopify/files/app/api/auth/shopify/callback/route.ts

@@ -0,0 +1,11 @@
+/**
+ * Shopify OAuth Callback
+ */
+
+import { shopifyConfig, createOAuthCallbackHandler, memoryTokenStore } from "veryfront/oauth";
+
+export const GET = createOAuthCallbackHandler(shopifyConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

package/dist/integrations/shopify/files/app/api/auth/shopify/route.ts

@@ -0,0 +1,7 @@
+/**
+ * Shopify OAuth Init
+ */
+
+import { shopifyConfig, createOAuthInitHandler } from "veryfront/oauth";
+
+export const GET = createOAuthInitHandler(shopifyConfig);

package/dist/integrations/shopify/files/lib/shopify-client.ts

@@ -0,0 +1,198 @@
+import { getAccessToken } from "./token-store.ts";
+
+const SHOPIFY_SHOP_DOMAIN = process.env.SHOPIFY_SHOP_DOMAIN || "shop.myshopify.com";
+const SHOPIFY_API_VERSION = "2024-01";
+const SHOPIFY_BASE_URL = `https://${SHOPIFY_SHOP_DOMAIN}/admin/api/${SHOPIFY_API_VERSION}`;
+
+interface ShopifyProduct {
+  id: number;
+  title: string;
+  body_html: string;
+  vendor: string;
+  product_type: string;
+  created_at: string;
+  updated_at: string;
+  published_at: string | null;
+  status: string;
+  tags: string;
+  variants: Array<{
+    id: number;
+    title: string;
+    price: string;
+    sku: string;
+    inventory_quantity: number;
+  }>;
+  images: Array<{
+    id: number;
+    src: string;
+    alt: string | null;
+  }>;
+}
+
+interface ShopifyOrder {
+  id: number;
+  order_number: number;
+  email: string;
+  created_at: string;
+  updated_at: string;
+  total_price: string;
+  subtotal_price: string;
+  total_tax: string;
+  currency: string;
+  financial_status: string;
+  fulfillment_status: string | null;
+  customer: {
+    id: number;
+    email: string;
+    first_name: string;
+    last_name: string;
+  } | null;
+  line_items: Array<{
+    id: number;
+    title: string;
+    quantity: number;
+    price: string;
+    sku: string;
+    variant_title: string;
+  }>;
+  shipping_address: {
+    address1: string;
+    city: string;
+    province: string;
+    country: string;
+    zip: string;
+  } | null;
+}
+
+interface ShopifyCustomer {
+  id: number;
+  email: string;
+  first_name: string;
+  last_name: string;
+  phone: string | null;
+  created_at: string;
+  updated_at: string;
+  orders_count: number;
+  total_spent: string;
+  tags: string;
+  state: string;
+  verified_email: boolean;
+  addresses: Array<{
+    id: number;
+    address1: string;
+    city: string;
+    province: string;
+    country: string;
+    zip: string;
+    default: boolean;
+  }>;
+}
+
+async function shopifyFetch<T>(
+  endpoint: string,
+  options: RequestInit = {},
+): Promise<T> {
+  const token = await getAccessToken();
+  if (!token) {
+    throw new Error("Not authenticated with Shopify. Please connect your account.");
+  }
+
+  const response = await fetch(`${SHOPIFY_BASE_URL}${endpoint}`, {
+    ...options,
+    headers: {
+      "X-Shopify-Access-Token": token,
+      "Content-Type": "application/json",
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({}));
+    throw new Error(
+      `Shopify API error: ${response.status} ${error.errors || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+export async function listProducts(options?: {
+  limit?: number;
+  status?: "active" | "archived" | "draft";
+  productType?: string;
+}): Promise<ShopifyProduct[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", options.limit.toString());
+  if (options?.status) params.set("status", options.status);
+  if (options?.productType) params.set("product_type", options.productType);
+
+  const query = params.toString() ? `?${params}` : "";
+  const response = await shopifyFetch<{ products: ShopifyProduct[] }>(`/products.json${query}`);
+  return response.products;
+}
+
+export async function getProduct(productId: number | string): Promise<ShopifyProduct> {
+  const response = await shopifyFetch<{ product: ShopifyProduct }>(`/products/${productId}.json`);
+  return response.product;
+}
+
+export async function listOrders(options?: {
+  limit?: number;
+  status?: "open" | "closed" | "cancelled" | "any";
+  financialStatus?: "pending" | "authorized" | "paid" | "refunded" | "voided";
+  fulfillmentStatus?: "shipped" | "partial" | "unshipped" | "any" | "unfulfilled";
+}): Promise<ShopifyOrder[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", options.limit.toString());
+  if (options?.status) params.set("status", options.status);
+  if (options?.financialStatus) params.set("financial_status", options.financialStatus);
+  if (options?.fulfillmentStatus) params.set("fulfillment_status", options.fulfillmentStatus);
+
+  const query = params.toString() ? `?${params}` : "";
+  const response = await shopifyFetch<{ orders: ShopifyOrder[] }>(`/orders.json${query}`);
+  return response.orders;
+}
+
+export async function getOrder(orderId: number | string): Promise<ShopifyOrder> {
+  const response = await shopifyFetch<{ order: ShopifyOrder }>(`/orders/${orderId}.json`);
+  return response.order;
+}
+
+export async function listCustomers(options?: {
+  limit?: number;
+  query?: string;
+}): Promise<ShopifyCustomer[]> {
+  const params = new URLSearchParams();
+  if (options?.limit) params.set("limit", options.limit.toString());
+  if (options?.query) params.set("query", options.query);
+
+  const query = params.toString() ? `?${params}` : "";
+  const response = await shopifyFetch<{ customers: ShopifyCustomer[] }>(`/customers.json${query}`);
+  return response.customers;
+}
+
+export async function getCustomer(customerId: number | string): Promise<ShopifyCustomer> {
+  const response = await shopifyFetch<{ customer: ShopifyCustomer }>(`/customers/${customerId}.json`);
+  return response.customer;
+}
+
+export async function getShopInfo(): Promise<{
+  id: number;
+  name: string;
+  email: string;
+  domain: string;
+  currency: string;
+  timezone: string;
+}> {
+  const response = await shopifyFetch<{
+    shop: {
+      id: number;
+      name: string;
+      email: string;
+      domain: string;
+      currency: string;
+      timezone: string;
+    };
+  }>("/shop.json");
+  return response.shop;
+}

package/dist/integrations/shopify/files/lib/token-store.ts

@@ -0,0 +1,11 @@
+/**
+ * Shopify Token Store
+ */
+
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";
+
+export async function getAccessToken(): Promise<string | null> {
+  const { tokenStore } = await import("./token-store.ts");
+  const tokens = await tokenStore.get("shopify");
+  return tokens?.accessToken ?? null;
+}

package/dist/integrations/slack/files/app/api/auth/slack/callback/route.ts

@@ -1,132 +1,11 @@
 /**
  * Slack OAuth Callback
- *
- * Handles the OAuth callback from Slack, exchanges code for tokens,
- * and stores them securely.
  */
 
-import { tokenStore } from "../../../../../lib/token-store.ts";
-import { slackOAuthProvider } from "../../../../../lib/slack-client.ts";
+import { createOAuthCallbackHandler, memoryTokenStore, slackConfig } from "veryfront/oauth";
 
-export async function GET(req: Request) {
-  const url = new URL(req.url);
-  const code = url.searchParams.get("code");
-  const state = url.searchParams.get("state");
-  const error = url.searchParams.get("error");
-
-  // Handle OAuth errors
-  if (error) {
-    const errorDescription = url.searchParams.get("error_description") || error;
-    return new Response(
-      `
-      <html>
-        <head><title>Connection Failed</title></head>
-        <body style="font-family: system-ui; padding: 40px; text-align: center;">
-          <h1>Slack Connection Failed</h1>
-          <p style="color: #666;">${errorDescription}</p>
-          <a href="/" style="color: #0066cc;">Return to App</a>
-        </body>
-      </html>
-      `,
-      {
-        status: 400,
-        headers: { "Content-Type": "text/html" },
-      },
-    );
-  }
-
-  if (!code || !state) {
-    return new Response("Missing code or state parameter", { status: 400 });
-  }
-
-  // Validate state from cookie
-  const cookies = req.headers.get("cookie") || "";
-  const stateCookie = cookies
-    .split(";")
-    .find((c) => c.trim().startsWith("slack_oauth_state="));
-  const savedState = stateCookie?.split("=")[1]?.trim();
-
-  if (state !== savedState) {
-    return new Response("Invalid state parameter", { status: 400 });
-  }
-
-  try {
-    const origin = url.origin;
-    const redirectUri = `${origin}${slackOAuthProvider.callbackPath}`;
-
-    // Exchange code for tokens using Slack's specific OAuth flow
-    const response = await fetch(slackOAuthProvider.tokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-      },
-      body: new URLSearchParams({
-        client_id: slackOAuthProvider.clientId,
-        client_secret: slackOAuthProvider.clientSecret,
-        code,
-        redirect_uri: redirectUri,
-      }),
-    });
-
-    const data = await response.json();
-
-    if (!data.ok) {
-      throw new Error(data.error || "Token exchange failed");
-    }
-
-    // Get actual user ID from session in production
-    const userId = "current-user";
-
-    // Store tokens (Slack returns access_token in authed_user or at top level)
-    const accessToken = data.authed_user?.access_token || data.access_token;
-    await tokenStore.setToken(userId, "slack", {
-      accessToken,
-      refreshToken: data.refresh_token,
-      scope: data.scope,
-      tokenType: data.token_type,
-    });
-
-    // Clear state cookie and redirect to success page
-    return new Response(
-      `
-      <html>
-        <head>
-          <title>Slack Connected</title>
-          <meta http-equiv="refresh" content="2;url=/" />
-        </head>
-        <body style="font-family: system-ui; padding: 40px; text-align: center;">
-          <h1 style="color: #22c55e;">✓ Slack Connected!</h1>
-          <p style="color: #666;">Your Slack workspace has been connected successfully.</p>
-          <p style="color: #999; font-size: 14px;">Redirecting...</p>
-          <a href="/" style="color: #0066cc;">Return to App</a>
-        </body>
-      </html>
-      `,
-      {
-        status: 200,
-        headers: {
-          "Content-Type": "text/html",
-          "Set-Cookie": "slack_oauth_state=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0",
-        },
-      },
-    );
-  } catch (err) {
-    console.error("Slack OAuth error:", err);
-    return new Response(
-      `
-      <html>
-        <head><title>Connection Failed</title></head>
-        <body style="font-family: system-ui; padding: 40px; text-align: center;">
-          <h1>Slack Connection Failed</h1>
-          <p style="color: #666;">Unable to complete Slack authorization. Please try again.</p>
-          <a href="/api/auth/slack" style="color: #0066cc;">Try Again</a>
-        </body>
-      </html>
-      `,
-      {
-        status: 500,
-        headers: { "Content-Type": "text/html" },
-      },
-    );
-  }
-}
+export const GET = createOAuthCallbackHandler(slackConfig, {
+  tokenStore: memoryTokenStore,
+  onSuccess: () => "/",
+  onError: () => "/",
+});

package/dist/integrations/slack/files/app/api/auth/slack/route.ts

@@ -1,29 +1,9 @@
 /**
  * Slack OAuth Initiation
- *
- * Redirects to Slack OAuth consent screen
  */
 
-import { getAuthorizationUrl } from "../../../../lib/oauth.ts";
-import { slackOAuthProvider } from "../../../../lib/slack-client.ts";
+import { createOAuthInitHandler, memoryTokenStore, slackConfig } from "veryfront/oauth";
 
-export function GET(req: Request) {
-  const url = new URL(req.url);
-  const origin = url.origin;
-
-  // Generate a random state for CSRF protection
-  const state = crypto.randomUUID();
-
-  // Store state in a cookie for validation
-  const redirectUri = `${origin}${slackOAuthProvider.callbackPath}`;
-  const authUrl = getAuthorizationUrl(slackOAuthProvider, state, redirectUri);
-
-  // Set state cookie and redirect to Slack
-  return new Response(null, {
-    status: 302,
-    headers: {
-      Location: authUrl,
-      "Set-Cookie": `slack_oauth_state=${state}; Path=/; HttpOnly; SameSite=Lax; Max-Age=600`,
-    },
-  });
-}
+export const GET = createOAuthInitHandler(slackConfig, {
+  tokenStore: memoryTokenStore,
+});

package/dist/integrations/slack/files/lib/token-store.ts

@@ -1,113 +1,5 @@
 /**
- * OAuth Token Store
- *
- * Simple in-memory token store for development.
- * Replace with a database or KV store for production.
+ * Slack Token Store
  */
 
-export interface OAuthToken {
-  accessToken: string;
-  refreshToken?: string;
-  expiresAt?: number;
-  tokenType?: string;
-  scope?: string;
-}
-
-export interface TokenStore {
-  getToken(userId: string, service: string): Promise<OAuthToken | null>;
-  setToken(userId: string, service: string, token: OAuthToken): Promise<void>;
-  revokeToken(userId: string, service: string): Promise<void>;
-  isConnected(userId: string, service: string): Promise<boolean>;
-}
-
-// In-memory storage for development
-// Use globalThis to share across esbuild bundles (each API route is bundled separately)
-const TOKENS_KEY = "__veryfront_oauth_tokens__";
-// deno-lint-ignore no-explicit-any
-const globalStore = globalThis as any;
-const tokens: Map<string, OAuthToken> = globalStore[TOKENS_KEY] ||= new Map<string, OAuthToken>();
-
-function getKey(userId: string, service: string): string {
-  return `${userId}:${service}`;
-}
-
-/**
- * Simple in-memory token store
- *
- * NOTE: This is for development only. In production, use:
- * - Database (Postgres, SQLite, etc.)
- * - KV store (Cloudflare Workers KV, Vercel KV, etc.)
- * - Encrypted file storage
- */
-export const tokenStore: TokenStore = {
-  getToken(userId: string, service: string): Promise<OAuthToken | null> {
-    const key = getKey(userId, service);
-    return Promise.resolve(tokens.get(key) || null);
-  },
-
-  setToken(
-    userId: string,
-    service: string,
-    token: OAuthToken,
-  ): Promise<void> {
-    const key = getKey(userId, service);
-    tokens.set(key, token);
-    return Promise.resolve();
-  },
-
-  revokeToken(userId: string, service: string): Promise<void> {
-    const key = getKey(userId, service);
-    tokens.delete(key);
-    return Promise.resolve();
-  },
-
-  async isConnected(userId: string, service: string): Promise<boolean> {
-    const token = await this.getToken(userId, service);
-    if (!token) return false;
-    // Check if token is not expired (if no expiry, token doesn't expire)
-    return !token.expiresAt || token.expiresAt > Date.now();
-  },
-};
-
-/**
- * Factory function to create a custom token store
- */
-export function createTokenStore(options: {
-  get: (key: string) => Promise<string | null>;
-  set: (key: string, value: string) => Promise<void>;
-  delete: (key: string) => Promise<void>;
-}): TokenStore {
-  return {
-    async getToken(userId: string, service: string): Promise<OAuthToken | null> {
-      const key = getKey(userId, service);
-      const data = await options.get(key);
-      if (!data) return null;
-      try {
-        return JSON.parse(data) as OAuthToken;
-      } catch {
-        return null;
-      }
-    },
-
-    async setToken(
-      userId: string,
-      service: string,
-      token: OAuthToken,
-    ): Promise<void> {
-      const key = getKey(userId, service);
-      await options.set(key, JSON.stringify(token));
-    },
-
-    async revokeToken(userId: string, service: string): Promise<void> {
-      const key = getKey(userId, service);
-      await options.delete(key);
-    },
-
-    async isConnected(userId: string, service: string): Promise<boolean> {
-      const token = await this.getToken(userId, service);
-      if (!token) return false;
-      // Check if token is not expired (if no expiry, token doesn't expire)
-      return !token.expiresAt || token.expiresAt > Date.now();
-    },
-  };
-}
+export { memoryTokenStore as tokenStore, type OAuthTokens, type TokenStore } from "veryfront/oauth";