@nano-app/backend 0.6.5 → 0.7.0

package/build/index.js

@@ -0,0 +1,544 @@
+// src/app/NanoApp.ts
+import express from "express";
+
+// ../core/loader/FileLoader.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve as resolve2 } from "path";
+import { glob } from "glob";
+
+// ../core/loader/Validator.ts
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE"];
+var Validator = class {
+  static validators = {
+    "route": () => this.isRoute,
+    "store": () => this.isStore,
+    "prisma": () => this.isPrisma
+  };
+  /**
+   * Type guard for a `*.route.ts` entry.
+   */
+  static isRoute(entry, filePath) {
+    if (!entry || typeof entry !== "object") {
+      console.warn(`[nano-app] [WARNING] ${filePath}: the default export is not an object.`);
+      return false;
+    }
+    const route = entry;
+    if (route.expression && typeof route.expression !== "string") {
+      console.warn(`[nano-app] [WARNING] ${filePath}: "expression" must be a string.`);
+      return false;
+    }
+    for (const method of HTTP_METHODS) {
+      if (route[method] && typeof route[method] !== "function") {
+        console.warn(`[nano-app] [WARNING] ${filePath}: "${String(method)}" must be a function.`);
+        return false;
+      }
+    }
+    if (!HTTP_METHODS.some((method) => route[method])) {
+      console.warn(`[nano-app] [WARNING] ${filePath}: no defines any HTTP method.`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Type guard for a `*.store.ts` entry.
+   */
+  static isStore(entry, filePath) {
+    if (!entry || typeof entry !== "object") {
+      console.warn(`[nano-app] [WARNING] ${filePath}: the default export is not an object.`);
+      return false;
+    }
+    const store = entry;
+    if (store.type !== "app" && store.type !== "api") {
+      console.warn(`[nano-app] [WARNING] ${filePath}: "type" must be "app" or "api".`);
+      return false;
+    }
+    if (store.type === "api" && !store.path) {
+      console.warn(`[nano-app] [WARNING] ${filePath}: "path" is required for type "api".`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Type guard for a `.prisma` entry: the contents of the file, without comments.
+   */
+  static isPrisma(entry, filePath) {
+    if (typeof entry !== "string") {
+      console.warn(`[nano-app] [WARNING] ${filePath}: the contents are not a string.`);
+      return false;
+    }
+    const provider = entry.match(/datasource\s+\w+\s*\{[^}]*provider\s*=\s*["']([^"']+)["']/s)?.[1];
+    if (provider !== "postgresql") {
+      console.warn(`[nano-app] [WARNING] ${filePath}: the datasource provider must be "postgresql"${provider ? `, not "${provider}"` : ""}.`);
+      return false;
+    }
+    return true;
+  }
+  /** Validates a full map of entries and returns only the valid ones */
+  static validate(entries, extension) {
+    const valid = {};
+    for (const [filePath, entry] of Object.entries(entries)) {
+      const validated = this.validateUnique(entry, extension, filePath);
+      if (validated !== void 0) valid[filePath] = validated;
+    }
+    return valid;
+  }
+  /** Validates one entry: returns it when valid, `undefined` otherwise */
+  static validateUnique(entry, extension, filePath = "") {
+    return this.validators[extension]?.()(entry, filePath) ? entry : void 0;
+  }
+};
+
+// ../core/loader/FileReader.ts
+import { createJiti } from "jiti";
+import { isAbsolute, resolve } from "path";
+import { readFileSync, existsSync } from "fs";
+var FileReader = class {
+  // The Prisma runtime is loaded natively: through jiti its interop breaks the error messages
+  static jiti = createJiti(import.meta.url, { nativeModules: ["@prisma/client"] });
+  /** Loads a module via jiti */
+  static async loadModule(filePath, options = {}) {
+    return await this.jiti.import(
+      this.getAbsolutePath(filePath),
+      options
+    );
+  }
+  /** Reads the contents of a file */
+  static loadFile(filePath) {
+    const content = readFileSync(this.getAbsolutePath(filePath), "utf-8");
+    if (!content) {
+      throw new Error(`[nano-app] [ERROR] The file ${filePath} does not have valid content.`);
+    }
+    return content;
+  }
+  /** Resolves the absolute path of a file */
+  static getAbsolutePath(filePath) {
+    const absolutePath = isAbsolute(filePath) ? filePath : resolve(process.cwd(), filePath);
+    if (!existsSync(absolutePath)) {
+      throw new Error(`[nano-app] [ERROR] ${filePath} not found.`);
+    }
+    return absolutePath;
+  }
+};
+
+// ../core/loader/FileLoader.ts
+var FileLoader = class {
+  /**
+   * 1. Validates a `.prisma` file.
+   * 2. Loads a generated Prisma client module (`client.ts`, or `client.js`)
+   */
+  static async findPrismaClient(clientPath, schemaPath) {
+    const content = FileReader.loadFile(schemaPath).replace(/\/\/.*$/gm, "");
+    if (!Validator.validateUnique(content, "prisma", schemaPath)) {
+      throw new Error(`[nano-app] [ERROR] ${schemaPath} is not a valid Prisma schema.`);
+    }
+    try {
+      return (await FileReader.loadModule(clientPath))?.PrismaClient;
+    } catch (error) {
+      throw new Error(`[nano-app] [ERROR] The Prisma client ${clientPath} could not be loaded: ${error?.message ?? error}`);
+    }
+  }
+  /** Finds `*.<extension>.ts` (or built `.js`) files and returns `{ [subPath]: defaultExport }` */
+  static async findMany({ extension, savePath, sourceDir, save = false }) {
+    const srcDir = (sourceDir || `src/${extension}s`).replace(/^\.\//, "").replace(/\/$/, "");
+    const filePaths = await glob(`${srcDir}/**/*.${extension}.{ts,js}`, { posix: true, ignore: "**/*.d.ts" });
+    const entries = {};
+    for (const filePath of filePaths) {
+      const fileSubPath = filePath.slice(srcDir.length).replace(new RegExp(`\\.${extension}\\.(ts|js)$`), "");
+      entries[fileSubPath] = await FileReader.loadModule(filePath, { default: true });
+    }
+    const valid = Validator.validate(entries, extension);
+    if (save) {
+      this.save(valid, savePath || resolve2(process.cwd(), "node_modules", "@nano-app", "data", `${extension}s.cjs`));
+    }
+    return valid;
+  }
+  /** Writes a `{ [filePath]: fileDefaultExport }` map to the given path. */
+  static save(data, outPath) {
+    const SERIALIZE = (value, indent = 0) => {
+      const pad = "  ".repeat(indent);
+      const padInner = "  ".repeat(indent + 1);
+      if (value === null) return "null";
+      if (value === void 0) return "undefined";
+      if (typeof value === "function") return value.toString();
+      if (typeof value === "string") return JSON.stringify(value);
+      if (typeof value === "number" || typeof value === "boolean") return String(value);
+      if (Array.isArray(value)) {
+        if (value.length === 0) return "[]";
+        const items = value.map((v) => `${padInner}${SERIALIZE(v, indent + 1)}`).join(",\n");
+        return `[
+${items}
+${pad}]`;
+      }
+      if (typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0) return "{}";
+        const lines = entries.map(([k, v]) => `${padInner}${JSON.stringify(k)}: ${SERIALIZE(v, indent + 1)}`).join(",\n");
+        return `{
+${lines}
+${pad}}`;
+      }
+      return String(value);
+    };
+    const GENERATE_EXPORT = (content) => `${'// Auto-generated by @nano-app.\n// Do not edit manually.\n"use strict";\nmodule.exports = {\n' + content + "\n};"}`;
+    const output = GENERATE_EXPORT(
+      Object.entries(data).map(([filePath, value]) => `  ${JSON.stringify(filePath)}: ${SERIALIZE(value, 1)}`).join(",\n")
+    );
+    mkdirSync(dirname(outPath), { recursive: true });
+    writeFileSync(outPath, output, "utf-8");
+    console.log(`[nano-app] File generated: ${outPath}`);
+  }
+};
+
+// ../core/utils/Formatter.ts
+var Formatter = class {
+  static price(value) {
+    return `$${new Intl.NumberFormat("de-DE", { maximumFractionDigits: 0 }).format(value || 0)}`;
+  }
+  static logDate(date = /* @__PURE__ */ new Date()) {
+    return new Intl.DateTimeFormat("es-ES", {
+      year: "2-digit",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit"
+    }).format(date);
+  }
+  // public static sanitizeAndParse(result: ApiResponse): ApiResponse {
+  //   const jsonString = JSON.stringify(result);
+  //   // The regular expression matches the key "password": "any_value"
+  //   // where:
+  //   //   - "password" is wrapped in quotes.
+  //   //   - Optional spaces may surround the colon.
+  //   //   - The value is assumed to be wrapped in quotes.
+  //   const regex = /("password"\s*:\s*)"[^"]*"/gi;
+  //   // Replace the value with the JSON literal null (unquoted)
+  //   const sanitizedString = jsonString.replace(regex, '$1null');
+  //   return JSON.parse(sanitizedString);
+  // }
+};
+
+// src/routes/Endpoint.ts
+var Endpoint = class {
+  methods;
+  /** Allowed methods */
+  constructor(methods) {
+    this.methods = methods;
+  }
+  /** Handler for all methods */
+  getHandler = (db) => (req, res, next) => {
+    const method = req.method.toUpperCase();
+    if (this.methods[method]) {
+      this.methods[method](req, db).then((response) => {
+        res.status(response.success ? 200 : 400).json(response);
+      }).catch(next);
+    } else {
+      res.status(405).json({ success: false, message: `Method ${method} not implemented` });
+    }
+  };
+};
+
+// src/routes/Router.ts
+var Router = class {
+  routes = {};
+  routesDir;
+  basePath;
+  constructor(routesDir, basePath) {
+    this.routesDir = routesDir;
+    this.basePath = basePath ?? "/";
+  }
+  async mount() {
+    if (!!this.routesDir) {
+      this.routes = await FileLoader.findMany({
+        sourceDir: this.routesDir,
+        extension: "route"
+      });
+    }
+    return Object.entries(this.routes).map(([filePath, { expression, ...methods }]) => {
+      const path = this.createPath(filePath, expression);
+      console.log(`[nano-app] [INFO] ${path}`);
+      return { path, endpoint: new Endpoint(methods) };
+    });
+  }
+  createPath(endpoint, expression) {
+    const isIndex = endpoint === "/index";
+    let path = isIndex ? "/" : endpoint;
+    if (!!expression) {
+      path = `${isIndex ? "" : endpoint.replace(/\/+$/, "")}/${expression.replace(/^\/+/, "")}`;
+    }
+    const basePath = this.basePath.replace(/\/+$/, "");
+    if (basePath) {
+      path = path === "/" ? basePath : `${basePath}${path}`;
+    }
+    return path;
+  }
+};
+
+// src/database/Database.ts
+import { existsSync as existsSync2 } from "fs";
+
+// const.ts
+import { dirname as dirname2, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+var BASE_DIR = dirname2(fileURLToPath(import.meta.url));
+var getDir = (...parts) => resolve3(BASE_DIR, ...parts);
+
+// src/database/Database.ts
+var Database = class {
+  static adapter;
+  /** Mounted clients, by name */
+  static clients = {};
+  /** Initializes the Database client */
+  static async init() {
+    const url = process.env.DATABASE_URL;
+    if (!url) {
+      throw new Error("[nano-app] [ERROR] The DATABASE_URL environment variable is not defined.");
+    }
+    const { PrismaPg } = await import("@prisma/adapter-pg");
+    this.adapter = new PrismaPg({ connectionString: url });
+  }
+  /** Gets a client by name */
+  static get(name) {
+    return this.clients[name];
+  }
+  /** Mounts a generated Prisma client */
+  static async mount(name, { schemaPath }) {
+    if (this.get(name)) {
+      throw new Error(`[nano-app] [ERROR] The database "${name}" is already mounted.`);
+    }
+    const clientPath = `${process.cwd()}/.nano-app/prisma-clients/${name}/generated/client.ts`;
+    if (!existsSync2(clientPath)) {
+      throw new Error(`[nano-app] [ERROR] The prisma client of "${name}" does not exist. Run \`npx nano-app generate ${name}\`.`);
+    }
+    if (!this.adapter) await this.init();
+    const PrismaClient = await FileLoader.findPrismaClient(clientPath, schemaPath);
+    const isPlugin = schemaPath.startsWith(getDir("plugins"));
+    const declared = FileReader.loadFile(schemaPath).replace(/\/\/.*$/gm, "").match(/datasource\s+\w+\s*\{[^}]*schemas\s*=\s*\[([^\]]*)\]/s)?.[1] ?? "";
+    const schemas = [...declared.matchAll(/["']([^"']+)["']/g)].map(([, schema]) => schema);
+    if (isPlugin ? !schemas.length || schemas.some((schema) => !schema.startsWith("nano_")) : schemas.some((schema) => schema.startsWith("nano_"))) {
+      throw new Error(`[nano-app] [ERROR] ${schemaPath}: ${isPlugin ? "a plugin declares only nano_* schemas" : "the nano_* schemas are reserved for plugins"}.`);
+    }
+    let client;
+    try {
+      client = new PrismaClient({ adapter: this.adapter });
+    } catch (error) {
+      throw new Error(`[nano-app] [ERROR] Cannot instantiate the database "${name}" from ${clientPath}: ${error?.message ?? error}`);
+    }
+    if (isPlugin) {
+      for (const [, model] of FileReader.loadFile(schemaPath).matchAll(/^\s*model\s+(\w+)/gm)) {
+        await client[model[0].toLowerCase() + model.slice(1)].findFirst().catch((error) => {
+          throw new Error(`[nano-app] [ERROR] The database "${name}" is not ready: ${String(error?.message ?? error).trim().split("\n").pop()} Run \`npx nano-app push ${name}\`.`);
+        });
+      }
+    }
+    this.clients[name] = client;
+    console.log(`[nano-app] [INFO] Database "${name}" mounted`);
+    return client;
+  }
+};
+
+// src/routes/Plugin.ts
+var Plugin = class {
+  config;
+  /** Creates a new Plugin instance */
+  constructor(config) {
+    this.config = config;
+  }
+  /** Mounts its endpoints on express app */
+  async mount(app) {
+    const { name, routesDir, basePath, database, init } = this.config;
+    const router = new Router(routesDir, basePath);
+    const db = database?.enabled ? await Database.mount(name, database) : void 0;
+    await init?.(app, db);
+    for (const { path, endpoint } of await router.mount()) app.all(path, endpoint.getHandler(db));
+  }
+};
+
+// src/app/NanoApp.ts
+import morgan from "morgan";
+import cors from "cors";
+import helmet from "helmet";
+import compression from "compression";
+import rateLimit from "express-rate-limit";
+import "dotenv/config";
+
+// src/app/config.ts
+var INITIAL_CONFIG = {
+  /** Initial application configuration */
+  port: 3e3,
+  /** Application listener */
+  listener: () => {
+  },
+  /** Express settings */
+  settings: {},
+  /** Initial middlewares */
+  packages: {
+    morgan: {
+      tokens: {
+        timestamp: () => Formatter.logDate()
+      },
+      format: ":timestamp | :method :url :status"
+    },
+    cors: {},
+    helmet: true,
+    compression: true,
+    rateLimit: {
+      max: 1e3,
+      message: "Too many requests, please try again later."
+    },
+    express: {
+      limit: "10kb"
+    },
+    urlencoded: {
+      extended: false
+    }
+  },
+  /** Main plugin to mount */
+  mainPlugin: {
+    routesDir: "src/routes",
+    basePath: "/",
+    database: {
+      enabled: false,
+      schemaPath: "src/prisma/schema.prisma"
+    }
+  },
+  /** Plugins around the consumer routes */
+  plugins: []
+};
+function mergeConfig(config = {}) {
+  return {
+    ...INITIAL_CONFIG,
+    ...config,
+    settings: config.settings ?? INITIAL_CONFIG.settings,
+    packages: {
+      ...INITIAL_CONFIG.packages,
+      ...config.packages || {},
+      morgan: config.packages?.morgan ?? INITIAL_CONFIG.packages.morgan,
+      cors: config.packages?.cors ?? INITIAL_CONFIG.packages.cors,
+      helmet: config.packages?.helmet ?? INITIAL_CONFIG.packages.helmet,
+      compression: config.packages?.compression ?? INITIAL_CONFIG.packages.compression,
+      rateLimit: config.packages?.rateLimit ?? INITIAL_CONFIG.packages.rateLimit,
+      express: config.packages?.express ?? INITIAL_CONFIG.packages.express,
+      urlencoded: config.packages?.urlencoded ?? INITIAL_CONFIG.packages.urlencoded
+    },
+    mainPlugin: {
+      ...INITIAL_CONFIG.mainPlugin,
+      ...config.mainPlugin,
+      name: "app",
+      database: {
+        ...INITIAL_CONFIG.mainPlugin.database,
+        ...config.mainPlugin?.database
+      }
+    },
+    plugins: config.plugins ?? INITIAL_CONFIG.plugins
+  };
+}
+
+// src/app/errors.ts
+function normalize(error) {
+  if (typeof error === "string") {
+    return { status: 400, body: { success: false, message: error } };
+  }
+  const { status, message, warning } = error ?? {};
+  return {
+    status: status ?? 500,
+    body: {
+      success: false,
+      warning: warning ?? false,
+      message: message || "Internal server error"
+    }
+  };
+}
+var notFoundHandler = (req, _res, next) => {
+  next({ status: 404, message: `${req.path} not found` });
+};
+var errorHandler = (error, _req, res, _next) => {
+  const { status, body } = normalize(error);
+  if (status >= 500) {
+    console.error("[nano-app] [ERROR]", error);
+  }
+  res.status(status).json(body);
+};
+
+// src/app/NanoApp.ts
+var NanoApp = class {
+  app;
+  config;
+  constructor(config = {}) {
+    this.app = express();
+    this.config = mergeConfig(config);
+    this.start();
+  }
+  /** Starts the application */
+  async start() {
+    try {
+      await this.initialize();
+      this.app.listen(Number(this.config.port), () => {
+        this.config.listener?.();
+        console.log(`
+[nano-app] [INFO] Nano App running on port ${this.config.port}
+`);
+      });
+      return this;
+    } catch (error) {
+      console.error("[nano-app] [ERROR] Error trying to start the server.", error);
+      process.exit(1);
+    }
+  }
+  /** Initializes the application in the right order */
+  async initialize() {
+    Object.entries(this.config.settings ?? {}).forEach(([key, value]) => this.app.set(key, value));
+    this.setPackages(this.config.packages);
+    const oPlugins = { before: [], after: [] };
+    this.config.plugins?.forEach((plugin) => {
+      oPlugins[plugin.stage ?? "before"].push(plugin);
+    });
+    for (const plugin of oPlugins.before) await new Plugin(plugin).mount(this.app);
+    await new Plugin(this.config.mainPlugin).mount(this.app);
+    for (const plugin of oPlugins.after) await new Plugin(plugin).mount(this.app);
+    this.app.use(notFoundHandler);
+    this.app.use(errorHandler);
+  }
+  /* Adds the packages according to the configuration */
+  setPackages(config = {}) {
+    if (config.morgan) {
+      Object.entries(config.morgan.tokens ?? {}).forEach(([key, value]) => morgan.token(key, value));
+      this.app.use(morgan(config.morgan.format));
+    }
+    if (config.cors) {
+      this.app.use(cors(config.cors));
+    }
+    if (config.helmet) {
+      this.app.use(helmet());
+    }
+    if (config.compression) {
+      this.app.use(compression());
+    }
+    if (config.rateLimit) {
+      this.app.use(rateLimit(config.rateLimit));
+    }
+    if (config.express) {
+      this.app.use(express.json(config.express));
+    }
+    if (config.urlencoded) {
+      this.app.use(express.urlencoded(config.urlencoded));
+    }
+  }
+};
+
+// src/app/creators.ts
+function createNanoApp(config) {
+  return new NanoApp(config);
+}
+function createRoute(route) {
+  return route;
+}
+function createPlugin(creator) {
+  return creator;
+}
+export {
+  NanoApp,
+  createNanoApp,
+  createPlugin,
+  createRoute
+};

package/build/nano-app.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+// bin/nano-app.ts
+import "dotenv/config";
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+
+// const.ts
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var BASE_DIR = dirname(fileURLToPath(import.meta.url));
+var getDir = (...parts) => resolve(BASE_DIR, ...parts);
+
+// bin/nano-app.ts
+var [command, ...args] = process.argv.slice(2);
+var prisma = (...prismaArgs) => execFileSync(process.execPath, [createRequire(`${process.cwd()}/`).resolve("prisma/build/index.js"), ...prismaArgs], { stdio: "inherit" });
+try {
+  if (command !== "generate" && command !== "push") {
+    prisma(...process.argv.slice(2));
+  } else {
+    const schemaFlag = args.indexOf("--schema");
+    const appSchema = schemaFlag >= 0 ? args.splice(schemaFlag, 2)[1] : "src/prisma/schema.prisma";
+    const names = args.filter((arg) => !arg.startsWith("-"));
+    const flags = args.filter((arg) => arg.startsWith("-"));
+    for (const name of names.length ? names : ["app"]) {
+      const source = name === "app" ? appSchema : getDir("plugins", name, "schema.prisma");
+      if (!existsSync(source)) {
+        console.error(`[nano-app] [ERROR] "${name}" has no schema: ${source}`);
+        process.exit(1);
+      }
+      const dir = `${process.cwd()}/.nano-app/prisma-clients/${name}`;
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(`${dir}/schema.prisma`, readFileSync(source, "utf-8").replace(/output\s*=\s*"[^"]*"/, 'output = "./generated"'));
+      prisma("generate", "--schema", `${dir}/schema.prisma`);
+      if (command === "push") prisma("db", "push", "--schema", `${dir}/schema.prisma`, "--url", process.env.DATABASE_URL ?? "", ...flags);
+    }
+  }
+} catch (error) {
+  process.exit(error?.status ?? 1);
+}