feat: add main features

Author: damilola-paystack

README.md

@@ -1,8 +1,36 @@
-```
-npm install
-npm run dev
-```
+# sample-subscription-backend
+A simple backend to serve as a reference when building subscription or recurring bill payment apps [with Paystack](https://paystack.com/). You can [check out the documentation](https://paystack.com/docs/payments/subscriptions/) to learn more.
 
-```
-open http://localhost:3000
-```
+## Tech stack
+- [Hono](https://hono.dev/)
+- SQLite
+- [Drizzle ORM](https://orm.drizzle.team/)
+- Paystack Subscription
+
+## Set up
+- Clone the repo:
+  ```sh
+  git clone git@github.com:PaystackOSS/sample-subscription-backend.git
+  ```
+- Install dependencies
+  ```
+  pnpm install
+  ```
+- Set up the DB
+  ```sh
+  pnpm db:apply
+  ```
+- Start server
+  ```sh
+  pnpm dev
+  ```
+- Test endpoints
+  ```sh
+  open http://localhost:3030
+  ```
+
+## Code structure
+The code has a simple structure where all configuration files are in the top level and core logic resides on the `src` directory:
+- `db`: Contains the DB schema
+- `routes`: Each feature is categorised by routes that is then exported for usage in the main Hono class
+- `schema`: Contains basic [Zod schema](https://zod.dev/) request validation

package.json

@@ -2,7 +2,7 @@
   "name": "sample-subscription-backend",
   "type": "module",
   "scripts": {
-    "db:apply": "npx drizzle-kit push",
+    "db:apply": "NODE_OPTIONS='--import tsx' drizzle-kit push",
     "dev": "tsx watch src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js"

src/db/schema/customers.ts

@@ -0,0 +1,9 @@
+import { int, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const customersTable = sqliteTable("customers", {
+  id: int().primaryKey({ autoIncrement: true }),
+  firstName: text().notNull(),
+  lastName: text().notNull(),
+  email: text().notNull().unique(),
+  code: text().notNull().unique(),
+});

src/db/schema/subscriptions.ts

@@ -0,0 +1,13 @@
+import { int, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { customersTable } from "./customers.js";
+import { plansTable } from "./plans.js";
+
+export const subscriptionsTable = sqliteTable("subscriptions", {
+  id: int().primaryKey({ autoIncrement: true }),
+  code: text().notNull(),
+  status: text().notNull(),
+  plan: int().notNull().references(() => plansTable.id),
+  customer: int().notNull().references(() => customersTable.id),
+  emailToken: text().notNull(),
+  nextPaymentDate: text().notNull()
+});

src/db/schema/transactions.ts

@@ -0,0 +1,11 @@
+import { int, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { plansTable } from "./plans.js";
+import { customersTable } from "./customers.js";
+
+export const transactionsTable = sqliteTable("transactions", {
+  id: int().primaryKey({ autoIncrement: true }),
+  amount: int().notNull().default(0),
+  reference: text().notNull(),
+  plan: int().references(() => plansTable.id),
+  customer: int().references(() => customersTable.id),
+});

src/index.ts

@@ -4,6 +4,8 @@ import plansRouter from './routes/plans.js'
 import { showRoutes } from 'hono/dev'
 import transactionRouter from './routes/transaction.js'
 import webhookRouter from './routes/webhooks.js'
+import customersRouter from './routes/customer.js'
+import subscriptionsRouter from './routes/subscriptions.js'
 
 const app = new Hono()
 
@@ -12,15 +14,17 @@ app.get('/', (c) => {
 })
 
 app.route("/plan", plansRouter)
+app.route("/customer", customersRouter)
 app.route("/transaction", transactionRouter)
+app.route("/subscription", subscriptionsRouter)
 app.route("/webhook", webhookRouter)
 
 // To list all routes
 showRoutes(app)
 
 serve({
   fetch: app.fetch,
-  port: 3000
+  port: 3030
 }, (info) => {
   console.log(`Server is running on http://localhost:${info.port}`)
 })

src/routes/customer.ts

@@ -0,0 +1,108 @@
+import 'dotenv/config';
+import { Hono } from "hono";
+import { db } from '../db.js';
+import { zValidator } from '@hono/zod-validator';
+import { Customer, CustomerUpdate } from '../schema/index.js';
+import { eq } from 'drizzle-orm';
+import { customersTable } from '../db/schema/customers.js';
+
+const customersRouter = new Hono()
+
+customersRouter.post("/insert", async (c) => {
+  const data = await c.req.json()
+
+  const {
+    first_name,
+    last_name,
+    email,
+    code
+  } = data
+
+  const customer = await db.insert(customersTable)
+    .values({
+      firstName: first_name,
+      lastName: last_name,
+      email: email,
+      code: code
+    })
+    .returning()
+
+  return c.json({
+    status: true,
+    data: customer[0]
+  }, 201)
+})
+
+customersRouter.get("/", async (c) => {
+  const customers = await db.select().from(customersTable)
+
+  return c.json({
+    status: true,
+    data: customers,
+  }, 200)
+})
+
+customersRouter.post("/",
+  zValidator('json', Customer),
+  async (c) => {
+    const validateReq = c.req.valid('json')
+    const api = await fetch(`${process.env.PAYSTACK_BASE_URL}/customer`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${process.env.PAYSTACK_SECRET_KEY}`,
+        'Content-Type': "application/json"
+      },
+      body: JSON.stringify(validateReq)
+    })
+
+    const data = await api.json()
+
+    if (!data["status"]) {
+      return c.json({
+        status: false,
+        data: {}
+      }, 500)
+    }
+
+    const {
+      first_name,
+      last_name,
+      email,
+      customer_code
+    } = data["data"]
+
+    const customer = await db.insert(customersTable)
+      .values({
+        firstName: first_name,
+        lastName: last_name,
+        email: email,
+        code: customer_code
+      })
+      .returning()
+
+    return c.json({
+      status: true,
+      data: customer[0]
+    }, 201)
+  }
+)
+
+customersRouter.put("/:id",
+  zValidator('json', CustomerUpdate),
+  async (c) => {
+    const validatedReq = c.req.valid('json')
+    const id = c.req.param('id')
+
+    const customer = await db.update(customersTable)
+      .set({ ...validatedReq })
+      .where(eq(customersTable.id, parseInt(id)))
+      .returning();
+
+    return c.json({
+      status: true,
+      data: customer[0]
+    }, 200)
+  }
+)
+
+export default customersRouter

src/routes/subscriptions.ts

@@ -0,0 +1,78 @@
+import 'dotenv/config';
+import { Hono } from "hono";
+import { db } from '../db.js';
+import { zValidator } from '@hono/zod-validator';
+import { SubscriptionCreate } from '../schema/index.js';
+import { eq } from 'drizzle-orm';
+import { subscriptionsTable } from '../db/schema/subscriptions.js';
+import { plansTable } from '../db/schema/plans.js';
+import { customersTable } from '../db/schema/customers.js';
+
+const subscriptionsRouter = new Hono()
+
+subscriptionsRouter.get("/", async (c) => {
+  const subscriptions = await db.select().from(subscriptionsTable)
+
+  return c.json({
+    status: true,
+    data: subscriptions,
+  }, 200)
+})
+
+subscriptionsRouter.post("/",
+  zValidator('json', SubscriptionCreate),
+  async (c) => {
+    const validateReq = c.req.valid('json')
+    const api = await fetch(`${process.env.PAYSTACK_BASE_URL}/subscription`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${process.env.PAYSTACK_SECRET_KEY}`,
+        'Content-Type': "application/json"
+      },
+      body: JSON.stringify(validateReq)
+    })
+
+    const data = await api.json()
+
+    if (!data["status"]) {
+      return c.json({
+        status: false,
+        data: {}
+      }, 500)
+    }
+
+    const {
+      subscription_code,
+      status,
+      plan: planCode,
+      customer: customerCode,
+      email_token,
+      next_payment_date
+    } = data["data"]
+    const plan = await db.select({ id: plansTable.id })
+      .from(plansTable)
+      .where(eq(plansTable.code, planCode))
+    const customer = await db.select({ id: customersTable.id })
+      .from(customersTable)
+      .where(eq(customerCode.code, customerCode))
+
+    const subscription = await db.insert(subscriptionsTable)
+      .values({
+        code: subscription_code,
+        status: status,
+        emailToken: email_token,
+        plan: plan[0].id,
+        customer: customer[0].id,
+        nextPaymentDate: next_payment_date
+      })
+      .returning()
+
+    return c.json({
+      status: true,
+      data: subscription[0]
+    }, 201)
+  }
+)
+
+
+export default subscriptionsRouter