@peepalytics/peepstick 0.1.0

package/README.md

@@ -0,0 +1,61 @@
+# @peepalytics/peepstick
+
+Drop-in ticket routing for Node apps, powered by PeepsTick. Configure the
+Slack destination once in the PeepsTick dashboard — this package just
+fetches your project's form schema and submits tickets to PeepsTick.
+It never talks to Slack directly.
+
+## Install
+
+```bash
+npm install @peepalytics/peepstick
+# or
+pnpm add @peepalytics/peepstick
+```
+
+It's a single published package — npm and pnpm both install the exact
+same code, so pick whichever your project already uses.
+
+Requires Node 18+ (uses the built-in `fetch`).
+
+## Core client (framework-agnostic)
+
+```js
+const { getFormSchema, submitTicket } = require("@peepalytics/peepstick");
+
+const config = { apiKey: process.env.PEEPSTICK_API_KEY, baseUrl: process.env.PEEPSTICK_BASE_URL };
+
+const formSchema = await getFormSchema(config);
+const ticket = await submitTicket({ ...config, fields: { title: "Login broken", priority: "High" } });
+```
+
+Both throw `PeepsTickError` on failure (network issues, invalid API key,
+missing required fields, etc).
+
+## Express integration
+
+If you're on Express, mount a ready-made router so your frontend calls
+your own server (keeping the API key out of the browser):
+
+```js
+const express = require("express");
+const { createTicketRouter } = require("@peepalytics/peepstick/express");
+
+const app = express();
+
+app.use(
+  "/peepstick",
+  createTicketRouter({
+    apiKey: process.env.PEEPSTICK_API_KEY,
+    baseUrl: process.env.PEEPSTICK_BASE_URL,
+  })
+);
+```
+
+This exposes:
+
+- `GET /peepstick/form-schema` — proxies the live schema from PeepsTick
+- `POST /peepstick/tickets` — proxies a submission (`{ "fields": {...} }`) to PeepsTick
+
+Your frontend JS fetches `/peepstick/form-schema` to render the form and
+posts to `/peepstick/tickets` on submit — same-origin, no API key exposed.

package/express.js

@@ -0,0 +1 @@
+module.exports = require("./src/express");

package/index.js

@@ -0,0 +1 @@
+module.exports = require("./src/client");

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@peepalytics/peepstick",
+  "version": "0.1.0",
+  "description": "Drop-in ticket routing for Node apps, powered by PeepsTick",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./express": "./express.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "express": "^5.2.1"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    }
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/client.js

@@ -0,0 +1,54 @@
+/**
+ * Thin HTTP client for the PeepsTick ticket-routing API.
+ *
+ * This is the only file that talks to the network. It never talks to
+ * Slack — it only ever calls your PeepsTick dashboard's API, which is the
+ * piece that owns the Slack webhook and does the actual posting.
+ */
+
+class PeepsTickError extends Error {}
+
+function headers(apiKey) {
+  return { "x-api-key": apiKey, "Content-Type": "application/json" };
+}
+
+async function parse(res) {
+  let data = {};
+  try {
+    data = await res.json();
+  } catch {
+    data = {};
+  }
+  if (!res.ok) {
+    throw new PeepsTickError(data.error || `PeepsTick API error (${res.status})`);
+  }
+  return data;
+}
+
+function request(baseUrl, path, options) {
+  const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+  return fetch(url, options).catch((err) => {
+    throw new PeepsTickError(`Could not reach PeepsTick at ${url}: ${err.message}`);
+  });
+}
+
+/** Fetches the live form schema configured for this project. */
+async function getFormSchema({ apiKey, baseUrl }) {
+  const res = await request(baseUrl, "/api/form-schema", { headers: headers(apiKey) });
+  const data = await parse(res);
+  return data.formSchema || [];
+}
+
+/** Submits ticket field values. PeepsTick validates, stores, and peepsticks to
+ * Slack server-side — this call never sees the webhook. */
+async function submitTicket({ apiKey, baseUrl, fields }) {
+  const res = await request(baseUrl, "/api/tickets", {
+    method: "POST",
+    headers: headers(apiKey),
+    body: JSON.stringify({ fields }),
+  });
+  const data = await parse(res);
+  return data.ticket;
+}
+
+module.exports = { getFormSchema, submitTicket, PeepsTickError };

package/src/express.js

@@ -0,0 +1,51 @@
+const express = require("express");
+const { getFormSchema, submitTicket, PeepsTickError } = require("./client");
+
+/**
+ * Creates an Express router with two routes:
+ *   GET  /form-schema  — proxies PeepsTick's live form schema to your frontend
+ *   POST /tickets      — proxies a submission to PeepsTick
+ *
+ * Mount it under your own server so the browser only ever talks to your
+ * app, never to PeepsTick directly — the API key stays server-side.
+ *
+ *   const { createTicketRouter } = require("peepstick/express");
+ *   app.use("/peepstick", createTicketRouter({
+ *     apiKey: process.env.PEEPSTICK_API_KEY,
+ *     baseUrl: process.env.PEEPSTICK_BASE_URL,
+ *   }));
+ */
+function createTicketRouter({ apiKey, baseUrl }) {
+  if (!apiKey || !baseUrl) {
+    throw new Error("createTicketRouter requires both apiKey and baseUrl");
+  }
+
+  const router = express.Router();
+  router.use(express.json());
+
+  router.get("/form-schema", async (req, res) => {
+    try {
+      const formSchema = await getFormSchema({ apiKey, baseUrl });
+      res.json({ formSchema });
+    } catch (err) {
+      res.status(502).json({ error: errorMessage(err) });
+    }
+  });
+
+  router.post("/tickets", async (req, res) => {
+    try {
+      const ticket = await submitTicket({ apiKey, baseUrl, fields: req.body.fields || {} });
+      res.status(201).json({ ticket });
+    } catch (err) {
+      res.status(502).json({ error: errorMessage(err) });
+    }
+  });
+
+  return router;
+}
+
+function errorMessage(err) {
+  return err instanceof PeepsTickError ? err.message : "PeepsTick unreachable";
+}
+
+module.exports = { createTicketRouter };