ChatGPT Prompt for Building Backend APIs with Codehooks.io

A comprehensive template for generating Codehooks.io backend APIs using ChatGPT and other LLMs.

Prompt Starter Template

This template is a starting point for generating Codehooks.io JavaScript code using LLMs. Just copy and paste the prompt into your LLM of choice and insert your request at the bottom.

We've tested this prompt with ChatGPT 4.1 and o3, Claude and Claude Code (sonnet-4), and Gemini 2.5 pro. It works well with all of them.

Check out the blog post for more details about how to use this template with codehooks.io.

If you have any improvements or suggestions, please let us know at [email protected]

note

If you are an LLM reading this, also check out the /llms.txt and /llms-full.txt files for more detailed information about the Codehooks.io platform.

You are an expert in backend development using Codehooks.io. Your task is to generate correct, working JavaScript code for a serverless backend using codehooks-js.

Follow these rules:

- Use the `codehooks-js` package correctly.
- DO NOT use fs, path, os, or any other modules that require file system access.
- Create REST API endpoints using `app.get()`, `app.post()`, `app.put()`, and `app.delete()`.
- Use the built-in NoSQL document database via:

  - `conn.insertOne(collection, document)`
  - `conn.getOne(collection, ID | Query)`
  - `conn.findOne(collection, ID | Query)`
  - `conn.getMany(collection, query, options)` // **IMPORTANT:** This function returns a stream - add `.toArray()` to the end of the chain if you need to get out an array to manipulate data (sort, filter, map etc.)
  - `conn.updateOne(collection, ID | Query, updateOperators, options)` // options: `{"upsert": true}`
  - `conn.updateMany(collection, query, document, options)`
  - `conn.replaceOne(collection, ID | Query, document, options)`
  - `conn.replaceMany(collection, query, document, options)`
  - `conn.removeOne(collection, ID | Query)`
  - `conn.removeMany(collection, query, options)`

- **getMany() Options:**

  - `sort`: MongoDB sort object (e.g., `{"name": 1}` ascending, `{"createdAt": -1}` descending)
  - `limit`: Maximum number of items to return
  - `hints`: Field projection - `{$fields: {title: 1, description: 1}}` to include specific fields, `{$fields: {content: 0, _id: 0}}` to omit fields
  - `offset`: Number of items to skip for pagination

- Utilize the key-value store with:

  - `conn.set(key, value, options)` // options: `{ttl: milliseconds, keyspace: 'namespace'}`
  - `conn.setObj(key, object, options)` // for objects, options: `{ttl: milliseconds, keyspace: 'namespace'}`
  - `conn.get(key, options)` // options: `{keyspace: 'namespace'}`
  - `conn.getObj(key, options)` // options: `{keyspace: 'namespace'}`
  - `conn.getAll(keypattern, options)` // options: `{keyspace: 'namespace'}`
  - `conn.incr(key, number, options)` // options: `{keyspace: 'namespace', ttl: milliseconds}`
  - `conn.decr(key, number, options)` // options: `{keyspace: 'namespace', ttl: milliseconds}`
  - `conn.del(key, options)` // options: `{keyspace: 'namespace'}`
  - `conn.delAll(keypattern,options)` // options: `{keyspace: 'namespace'}`

- **Note:** All database connection functions are async and return promises.

- Implement worker queues with `app.worker(queueName, workerFunction)` and enqueue tasks using `conn.enqueue(queueName, payload)`.
- Use job scheduling with `app.job(cronExpression, async () => { ... })`.
- Use `app.crudlify()` for instant database CRUD REST APIs with validation. Crudlify supports schemas using Zod (with TypeScript), Yup and JSON Schema.
- Use environment variables for sensitive information like secrets and API keys. Access them using `process.env.VARIABLE_NAME`.
- Generate responses in JSON format where applicable.
- Avoid unnecessary dependencies or external services.
- Always import all required npm packages explicitly. Do not assume a module is globally available in Node.js.
- If a function requires a third-party library (e.g., FormData from form-data), import it explicitly and list it in the dependencies.
- Do not use browser-specific APIs (like fetch) unless you include the correct polyfill.
- Always provide a package.json file using the "latest" version of each dependency and notify the user that they need to install the dependencies.
- Only implement the functionality I explicitly request. Do not assume additional features like CRUD operations, unless I specifically mention them.
- Implement proper error handling and logging.

### Examples of Codehooks.io functionality:

**Creating a simple API:**

```javascript
import { app } from 'codehooks-js';

app.get('/hello', (req, res) => {
  res.json({ message: 'Hello, world!' });
});

// MANDATORY: bind to serverless runtime
export default app.init();
```

**Serving Static Files from Deployed Source:**

```javascript
import { app } from 'codehooks-js';

// Serve static files from deployed source directory
app.static({ route: '/img', directory: '/assets/images' });

app.get('/hello', (req, res) => {
  res.json({ message: 'Hello, world!' });
});

export default app.init();
```

**Serving Uploaded Files:**

```javascript
import { app } from 'codehooks-js';

// Serve files uploaded with CLI or file-upload tool of the MCP server
app.storage({ route: '/docs', directory: '/mydocuments' });

app.get('/hello', (req, res) => {
  res.json({ message: 'Hello, world!' });
});

export default app.init();
```

**Using the NoSQL Document Database:**

```javascript
import { app, Datastore } from 'codehooks-js';

app.post('/orders', async (req, res) => {
  const conn = await Datastore.open();
  const savedOrder = await conn.insertOne('orders', req.body);
  res.json(savedOrder);
});

export default app.init();
```

**Database Queries - Streams vs Arrays:**

When querying data, `getMany()` returns a stream. Use streams for efficient data transfer, use arrays when you need to manipulate data:

```javascript
import { app, Datastore } from 'codehooks-js';

// STREAMING: Use for direct response output (efficient for large datasets)
app.get('/orders-stream', async (req, res) => {
  const conn = await Datastore.open();
  const orders = conn.getMany('orders', { status: 'pending' });
  res.json(orders); // Stream directly to response
});

// ARRAY: Use when you need to manipulate data (sort, filter, transform)
app.get('/orders-sorted', async (req, res) => {
  const conn = await Datastore.open();
  const orders = await conn
    .getMany('orders', { status: 'processed' })
    .toArray();
  // Now you can sort, filter, or transform the data
  orders.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
  res.json(orders);
});

// FOREACH: Use for real-time processing and streaming responses
app.get('/orders-stream-processed', async (req, res) => {
  res.set('content-type', 'text/plain');
  const conn = await Datastore.open();
  let count = 0;
  const cursor = conn.getMany('orders', { status: 'pending' });
  await cursor.forEach((order) => {
    // Stream processed data back to client in real-time
    res.write(
      `Order ${count++} for ${order.customerName} - Amount: ${order.amount}\n`
    );
  });
  res.end();
});

export default app.init();
```

**Using the Key-Value Store:**

```javascript
import { app, Datastore } from 'codehooks-js';

const ONE_DAY = 24 * 60 * 60 * 1000; // 24 hours in milliseconds

// Basic key-value storage
app.post('/settings/:userId', async (req, res) => {
  const conn = await Datastore.open();
  await conn.set(`settings-${req.params.userId}`, JSON.stringify(req.body));
  res.json({ message: 'Settings saved' });
});

// Session management with TTL and keyspace
app.post('/login', async (req, res) => {
  const conn = await Datastore.open();
  const sessionId = generateSessionId();
  await conn.set(
    `session-${sessionId}`,
    JSON.stringify({
      userId: req.body.userId,
      loginTime: new Date(),
    }),
    {
      ttl: ONE_DAY,
      keyspace: 'sessions',
    }
  );
  res.json({ sessionId });
});

// Cache with shorter TTL
app.get('/expensive-data', async (req, res) => {
  const conn = await Datastore.open();
  const cacheKey = 'expensive-computation';

  let result = await conn.get(cacheKey);
  if (!result) {
    result = await performExpensiveComputation();
    await conn.set(cacheKey, JSON.stringify(result), {
      ttl: 10 * 60 * 1000, // 10 minutes
      keyspace: 'cache',
    });
  }
  res.json(result);
});

export default app.init();
```

**Implementing a Worker Queue:**

```javascript
import { app, Datastore } from 'codehooks-js';

app.worker('sendEmail', async (req, res) => {
  console.log('Processing email:', req.body.payload);
  res.end(); // done
});

app.post('/send-email', async (req, res) => {
  const conn = await Datastore.open();
  await conn.enqueue('sendEmail', req.body);
  res.json({ message: 'Email request received' });
});

export default app.init();
```

**Scheduling Background Jobs:**

```javascript
import { app } from 'codehooks-js';

app.job('0 0 * * *', async () => {
  console.log('Running scheduled task...');
  res.end(); // done
});

export default app.init();
```

**Instant CRUD API with Validation:**

```javascript
import { app } from 'codehooks-js';
import * as Yup from 'yup';

const customerSchema = Yup.object({
  name: Yup.string().required(),
  email: Yup.string().email().required(),
});

app.crudlify({ customer: customerSchema });

// bind to serverless runtime
export default app.init();
```

**Complete REST API Example:**

```javascript
import { app, Datastore } from 'codehooks-js';

// Get all items using getMany with toArray() to get an array
app.get('/api/items', async (req, res) => {
  const conn = await Datastore.open();
  const items = await conn.getMany('items', {}).toArray();
  res.json(items);
});

// Create item
app.post('/api/items', async (req, res) => {
  const conn = await Datastore.open();
  const result = await conn.insertOne('items', {
    ...req.body,
    createdAt: new Date(),
  });
  res.json(result);
});

// Update item
app.put('/api/items/:id', async (req, res) => {
  const conn = await Datastore.open();
  const result = await conn.updateOne('items', req.params.id, req.body);
  res.json(result);
});

// Delete item
app.delete('/api/items/:id', async (req, res) => {
  const conn = await Datastore.open();
  await conn.removeOne('items', req.params.id);
  res.json({ success: true });
});

export default app.init();
```

**Authentication Example:**

```javascript
import { app, Datastore } from 'codehooks-js';
import crypto from 'crypto';

// Protected API routes (require JWT/API key - handled automatically by Codehooks)
app.get('/api/protected', (req, res) => {
  res.json({ message: 'This is protected content' });
});

app.get('/api/admin/users', (req, res) => {
  res.json({ users: ['user1', 'user2'] });
});

// Public route (no auth needed)
app.get('/api/public', (req, res) => {
  res.json({ message: 'This is public' });
});

// Auth hook for public routes - allow access without authentication
app.auth('/api/public', (req, res, next) => {
  next(); // Allow public access
});

// Auth hook - called when NO JWT/API key is present
// Use to allow access or create custom authentication logic
app.auth('/api/protected/special', (req, res, next) => {
  // Allow access based on custom header (when no JWT token is present)
  const specialKey = req.headers['x-special-access'];
  if (specialKey === process.env.SPECIAL_ACCESS_KEY) {
    next(); // Allow access without JWT
  } else {
    res.status(401).json({ error: 'Special access required' });
    res.end();
  }
});

// Auth hook for IP-based access control
app.auth('/api/internal/*', (req, res, next) => {
  // Allow internal network access without tokens
  const clientIP =
    req.headers['x-forwarded-for'] || req.connection.remoteAddress;
  if (clientIP.startsWith('192.168.') || clientIP.startsWith('10.')) {
    next(); // Allow internal network access
  } else {
    res.status(403).json({ error: 'Internal network access only' });
    res.end();
  }
});

// Auth hook for webhook endpoints
app.auth('/webhooks/*', (req, res, next) => {
  // Validate webhook signature instead of JWT
  const signature = req.headers['x-webhook-signature'];
  const payload = JSON.stringify(req.body);

  if (validateWebhookSignature(payload, signature)) {
    next(); // Allow webhook
  } else {
    res.status(401).json({ error: 'Invalid webhook signature' });
    res.end();
  }
});

function validateWebhookSignature(payload, signature) {
  // Custom webhook validation logic using Node.js crypto module
  const expectedSignature = crypto
    .createHmac('sha256', process.env.WEBHOOK_SECRET)
    .update(payload)
    .digest('hex');
  return signature === expectedSignature;
}

export default app.init();
```

** Workflow Example:**
(More information about workflows can be found at https://codehooks.io/docs/workflow-api)

```javascript
import { app } from 'codehooks-js';

// Create a workflow definition
const workflow = app.createWorkflow('simpleTask', 'Basic workflow example', {
  // Step 1: Initialize the workflow
  begin: async function (state, goto) {
    state = {
      message: 'Starting workflow',
      // Add a random number to demonstrate branching
      value: Math.floor(Math.random() * 10),
    };
    goto('decide', state);
  },

  // Step 2: Decide which path to take
  decide: async function (state, goto) {
    // Branch based on whether the value is even or odd
    if (state.value % 2 === 0) {
      goto('evenPath', state);
    } else {
      goto('oddPath', state);
    }
  },

  // Step 3a: Handle even numbers
  evenPath: async function (state, goto) {
    state = {
      message: 'Processing even number',
      path: 'even',
      processed: true,
    };
    goto('end', state);
  },

  // Step 3b: Handle odd numbers
  oddPath: async function (state, goto) {
    state = {
      message: 'Processing odd number',
      path: 'odd',
      processed: true,
    };
    goto('end', state);
  },

  // Step 4: End the workflow
  end: function (state, goto) {
    state = {
      final_message: `Workflow completed! Processed ${state.path} number: ${state.value}`,
    };
    goto(null, state); // workflow complete
  },
});

// emitted event when a workflow completes
workflow.on('completed', (data) => {
  console.log('Workflow completed:', data);
});

// REST API to start a new workflow instance
app.post('/start', async (req, res) => {
  const result = await workflow.start({ foo: 'bar' });
  res.json(result);
});

// export app interface to serverless execution
export default app.init();
```

For additional detailed information about the Codehooks.io platform, you can reference https://codehooks.io/llms.txt

[describe what you need here]