@rpcbase/api 0.0.0

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rpcbase/api",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "scripts": {
+    "build": "tsc --watch",
+    "release": "wireit"
+  },
+  "wireit": {
+    "release": {
+      "command": "../../scripts/publish.js",
+      "dependencies": [],
+      "files": [
+        "package.json"
+      ],
+      "output": [],
+      "env": {
+        "NPM_RELEASE_CHANNEL": {
+          "external": true
+        }
+      }
+    }
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "bluebird": "3.7.2",
+    "express": "5.0.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types"
+export * from "./initApi"
+export * from "./loadModel"

package/src/initApi.ts

@@ -0,0 +1,77 @@
+import assert from "assert"
+
+import BBPromise from "bluebird"
+import { Application , json } from "express"
+
+import { initApiClient } from "@rpcbase/client"
+
+import { Api, ApiHandler, Payload, Result, Middleware } from "./types"
+
+
+type RouteModule = [string, () => Promise<{default: (api: Api) => void}>]
+
+export const initApi = async (app: Application) => {
+
+  await initApiClient({app})
+
+  const registerHandler = (method: "get" | "post" | "put" | "delete", path: string, handler: ApiHandler) => {
+    assert(path.startsWith("/api"), "API routes must start with /api")
+
+    app[method](path, async(req, res, next) => {
+      const payload = req.body || {}
+
+      try {
+        const result = await handler(payload, {req, res})
+        res.json(result)
+      } catch (e) {
+        next(e)
+      }
+    })
+  }
+
+  const api = {
+    use: (path: string, middleware: Middleware): void => {
+      app.use(path, middleware)
+    },
+    get: (path: string, handler: ApiHandler): void => {
+      registerHandler("get", path, handler)
+    },
+    post: (path: string, handler: ApiHandler): void => {
+      registerHandler("post", path, handler)
+    }
+  }
+
+  // body parser
+  app.use("/api", json({limit: "8mb"}))
+
+  // WARNING:
+  // This is used to mark the start of the api middleware chain
+  // keep this middleware named like this, the serer api client will start calling middlewares starting from here
+  app.use("/api", function __FIRST_API_MIDDLEWARE__(_req, _res, next) {
+    next()
+  })
+
+  const routes = {
+    // @ts-ignore: Property 'glob' does not exist on type 'ImportMeta'.
+    ...import.meta.glob("../../auth/src/api/**/handler.ts"),
+    // @ts-ignore: Property 'glob' does not exist on type 'ImportMeta'.
+    ...import.meta.glob("@/api/**/handler.ts")
+  }
+
+  const routeEntries = Object.entries(routes) as RouteModule[]
+
+  const loadRoute = async([routePath, loadFn]: RouteModule) => {
+    const routeModule = await loadFn()
+    routeModule.default(api)
+    console.log("loaded api route", routePath)
+  }
+
+  await BBPromise.map(routeEntries, loadRoute)
+  console.log("Done loading routes")
+
+
+  app.use("/api", (req, res) => {
+    res.status(404).json({ error: `Not Found: ${req.method}:${req.originalUrl}` })
+  })
+
+}

package/src/loadModel.ts

@@ -0,0 +1,85 @@
+import assert from "assert"
+import mongoose from "mongoose"
+import { Ctx } from "./types"
+
+const { APP_NAME, DB_NAME } = process.env
+const connections: Record<string, mongoose.Connection> = {}
+
+// @ts-ignore: Property 'glob' does not exist on type 'ImportMeta'.
+const modelModules = import.meta.glob('@/models/**/*.ts', { eager: true })
+
+const models = Object.entries(modelModules)
+  .map(([key, exports]) => {
+    assert(key.startsWith("/src/models/"), "Expected Model path to start with /src/models/")
+
+    const modelName = key.replace("/src/models/", "").replace(".ts", "").split("/").pop()
+    assert(modelName, "Model name not found")
+
+    const schema = Object.entries(exports as Record<string, unknown>)
+      .find(([key]) => {
+        return key === `${modelName}Schema`
+      })
+
+    assert(schema, `Schema not found for model ${modelName}`)
+
+    return {
+      name: modelName,
+      model: mongoose.model(modelName, schema[1] as mongoose.Schema)
+    }
+  })
+  .reduce((acc, { name, model }) => {
+    acc[name] = model
+    return acc
+  }, {} as Record<string, mongoose.Model<any>>)
+
+
+export const loadModel = async (modelName: string, ctx: Ctx) => {
+
+  const tenantId = ctx.req.session.user?.current_tenant_id || "00000000"
+  assert(tenantId, "Tenant ID is missing from session")
+
+  const dbName = ["User", "Tenant"].includes(modelName)
+    ? `${APP_NAME}-users-${DB_NAME}`
+    : `${APP_NAME}-${tenantId}-${DB_NAME}`
+
+  const connectionString = `mongodb://localhost:27017/${dbName}`
+
+  if (!connections[dbName]) {
+    const connection = mongoose.createConnection(connectionString, {
+      sanitizeFilter: true,
+    })
+
+    await new Promise((resolve, reject) => {
+      connection.once("open", resolve)
+      connection.on("error", reject)
+    })
+
+    connections[dbName] = connection
+  } else {
+    const connection = connections[dbName]
+    if (connection.readyState !== 1) {
+      await new Promise((resolve, reject) => {
+        connection.once("open", resolve)
+        connection.on("error", reject)
+      })
+    }
+  }
+
+  const modelConnection = connections[dbName]
+
+  // const modelModule = Object.entries(models).find(([_, module]) =>
+  //   (module as { [key: string]: any })[modelName] !== undefined
+  // )?.[1] as { [key: string]: any } | undefined
+
+  // if (!modelModule) {
+  //   throw new Error(`Model ${modelName} not found in any directory`)
+  // }
+
+  const model = models[modelName]
+
+  if (!modelConnection.models[modelName]) {
+    modelConnection.model(modelName, model.schema)
+  }
+
+  return modelConnection.models[modelName]
+}

package/src/types.ts

@@ -0,0 +1,25 @@
+import type {Request, Response, NextFunction} from "express"
+
+
+export const MOCK_TYPE = "MOCK_TYPE"
+
+export type Ctx = {
+  req: Request;
+  res: Response;
+};
+
+
+// export type Payload = Record<string, unknown>
+export type Payload = any
+export type Result = Record<string, unknown>
+
+export type ApiHandler = (payload: Payload, ctx: Ctx) => Promise<Result>
+
+export type Middleware = (req: Request, res: Response, next: NextFunction) => void;
+
+
+export type Api = {
+  use: (path: string, middleware: Middleware) => void;
+  get: (path: string, handler: ApiHandler) => void;
+  post: (path: string, handler: ApiHandler) => void;
+}