AppEngine Integration

const appmintConfig = {
  useAppEngine: true,
  appengine: {
    host: process.env.APPENGINE_ENDPOINT,
    appId: process.env.APP_ID,
    key: process.env.APP_KEY,
    secret: process.env.APP_SECRET,
    apiKey: process.env.APPENGINE_API_KEY,
  },
  siteURL: process.env.SITE_URL,
  orgId: process.env.ORG_ID,
  siteName: process.env.SITE_NAME,
  domainAsOrg: process.env.DOMAIN_AS_ORG,
};

export { appmintConfig };

import { appmintConfig } from './appmint-config';
import axios from 'axios';

export class AppEngineClient {
  private token: string | null = null;

  constructor(private appConfig: any) {}

  // Automatically get app token using credentials
  async getAppToken() {
    const data = {
      appId: this.appConfig.appengine.appId,
      secret: this.appConfig.appengine.secret,
      key: this.appConfig.appengine.key,
    };

    // Calls profile/app/key endpoint to get token
    const response = await axios.post(
      `${this.appConfig.appengine.host}/profile/app/key`,
      data
    );
    return response.data.token;
  }

  // Get headers with authentication
  async getHeaderWithToken() {
    if (!this.token) {
      this.token = await this.getAppToken();
    }

    return {
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${this.token}`,
        'x-api-key': this.appConfig.appengine.apiKey,
        'org-id': this.appConfig.orgId,
      }
    };
  }

  // Process requests with automatic token renewal
  async processRequest(method: string, path: string, data?: any) {
    try {
      const headers = await this.getHeaderWithToken();
      const response = await axios({
        method,
        url: path,
        data,
        ...headers
      });

      return response.data;
    } catch (error: any) {
      // Auto-renew token if expired
      if (error?.response?.status === 401) {
        this.token = null;
        return this.processRequest(method, path, data);
      }
      throw error;
    }
  }
}

// Singleton instance
let appEngineClient: AppEngineClient;

export const getAppEngineClient = (): AppEngineClient => {
  if (!appEngineClient) {
    appEngineClient = new AppEngineClient(appmintConfig);
  }
  return appEngineClient;
};

import { getAppEngineClient } from '@/lib/appmint-client';

// Get the client instance
const appEngineClient = getAppEngineClient();

// Fetch data
const users = await appEngineClient.processRequest('GET', '/users');

// Create data
const newUser = await appEngineClient.processRequest('POST', '/users', {
  name: 'John Doe',
  email: 'john@example.com'
});

// Update data
const updatedUser = await appEngineClient.processRequest('PUT', '/users/123', {
  name: 'Jane Doe'
});

// Delete data
await appEngineClient.processRequest('DELETE', '/users/123');

// Use built-in repository methods
const userData = await appEngineClient.getById('users', '123');
const searchResults = await appEngineClient.findData('users', { name: 'john' });
const aggregated = await appEngineClient.processRequest('POST', '/repository/aggregate', data);

import { useState, useEffect } from 'react';

export function UserList() {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    // Client-side requests go through the proxy
    fetch('/api/users')
      .then(res => res.json())
      .then(data => setUsers(data));
  }, []);

  const createUser = async (userData) => {
    const response = await fetch('/api/users', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${getToken()}` // Optional: if using user tokens
      },
      body: JSON.stringify(userData)
    });

    return response.json();
  };

  return (
    <div>
      {users.map(user => (
        <div key={user.id}>{user.name}</div>
      ))}
    </div>
  );
}