@devbro/pashmak 0.1.55 → 0.1.57

package/dist/cjs/app/console/migrate/index.js

@@ -1749,6 +1749,51 @@ var DatabaseTransport = class {
 // src/factories.mts
 var import_neko_cache = require("@devbro/neko-cache");
 var import_neko_storage = require("@devbro/neko-storage");
+
+// src/cache/MultiCache.mts
+var MultiCache = class {
+  constructor(caches) {
+    this.caches = caches;
+  }
+  static {
+    __name(this, "MultiCache");
+  }
+  async get(key) {
+    for (const cache2 of this.caches) {
+      const value = await cache2.get(key);
+      if (value !== void 0) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  async put(key, value, ttl) {
+    await Promise.all(this.caches.map((cache2) => cache2.put(key, value, ttl)));
+  }
+  async delete(key) {
+    await Promise.all(this.caches.map((cache2) => cache2.delete(key)));
+  }
+  async has(key) {
+    for (const cache2 of this.caches) {
+      if (await cache2.has(key)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async increment(key, amount) {
+    let rc = void 0;
+    for (const cache2 of this.caches) {
+      let rc2 = await cache2.increment(key, amount);
+      if (rc === void 0) {
+        rc = rc2;
+      }
+    }
+    return rc;
+  }
+};
+
+// src/factories.mts
 var FlexibleFactory = class {
   static {
     __name(this, "FlexibleFactory");
@@ -1819,6 +1864,13 @@ CacheProviderFactory.register("redis", (opt) => {
 CacheProviderFactory.register("file", (opt) => {
   return new import_neko_cache.FileCacheProvider(opt);
 });
+CacheProviderFactory.register("multi", (opt) => {
+  const caches = [];
+  for (const c of opt.caches) {
+    caches.push(cache(c));
+  }
+  return new MultiCache(caches);
+});
 CacheProviderFactory.register("disabled", (opt) => {
   return new import_neko_cache.DisabledCacheProvider();
 });

package/dist/cjs/app/console/project/CreateProjectCommand.js

@@ -52,24 +52,17 @@ var CreateProjectCommand = class extends import_clipanion.Command {
     category: `Project`,
     description: `Create a new project`,
     details: `
-      This command creates a new project with the specified name at the given path.
-      If no path is provided, the project will be created in the current directory.
+      This command creates a new project interactively.
+      You will be prompted for the project path and other configuration options.
     `,
-    examples: [
-      [
-        `Create a new project in specified directory`,
-        `create project --path /path/to/my-project --git`
-      ],
-      [
-        `Create a new project at a specific path with git initialized`,
-        `create project --path /path/to/my-project --git`
-      ]
-    ]
-  });
-  projectPath = import_clipanion.Option.String("--path", { required: true });
-  git = import_clipanion.Option.Boolean(`--git`, false, {
-    description: `Initialize a git repository in the new project`
+    examples: [[`Create a new project`, `create project`]]
   });
+  projectPath = "";
+  executor = "";
+  packageManager = "";
+  linter = "";
+  validation_library = "";
+  database_type = "";
   async folderExists(folderPath) {
     try {
       const stats = await fs.stat(folderPath);
@@ -82,14 +75,148 @@ var CreateProjectCommand = class extends import_clipanion.Command {
     }
   }
   async execute() {
-    const projectPath = import_path.default.join(this.projectPath);
-    try {
-      await fs.access(projectPath);
-      console.error(`Error: Directory ${projectPath} already exists.`);
-      return 1;
-    } catch {
+    await this.setupProjectPath();
+    await this.setupGit();
+    await this.setupExecutorAndPackageManager();
+    await this.setupLinter();
+    await this.setupGeneralPackages();
+    await this.setupBaseProject();
+    await this.installPackages();
+  }
+  async processTplFolder(src, dest, data = {}) {
+    const files = await fs.readdir(src, { withFileTypes: true });
+    for (const file of files) {
+      const srcPath = import_path.default.join(src, file.name);
+      const destPath = file.isFile() && file.name.endsWith(".tpl") ? import_path.default.join(dest, file.name.substring(0, file.name.length - 4)) : import_path.default.join(dest, file.name);
+      if (file.isDirectory()) {
+        await fs.mkdir(destPath, { recursive: true });
+        await this.processTplFolder(srcPath, destPath, data);
+      } else if (file.name.endsWith(".tpl")) {
+        await this.processTplFile(srcPath, destPath, data);
+      } else {
+        throw new Error(
+          "unexpected non tpl file: " + srcPath + " " + file.name
+        );
+      }
+    }
+  }
+  async processTplFile(src, dest, data = {}) {
+    import_handlebars.default.registerHelper("eq", (a, b) => a === b);
+    const compiledTemplate = import_handlebars.default.compile(
+      (await fs.readFile(src)).toString()
+    );
+    const template = await compiledTemplate(data);
+    await fs.writeFile(dest, template);
+  }
+  async setupProjectPath() {
+    const pathInput = await (0, import_prompts.input)({
+      message: "Enter project path (leave empty to use current directory):",
+      default: ""
+    });
+    this.projectPath = pathInput.trim() ? import_path.default.resolve(pathInput.trim()) : process.cwd();
+    await fs.mkdir(this.projectPath, { recursive: true });
+    const files = await fs.readdir(this.projectPath);
+    if (files.length > 0) {
+      throw new Error(
+        `Directory ${this.projectPath} is not empty. Please use an empty directory.`
+      );
+    }
+  }
+  async setupExecutorAndPackageManager() {
+    this.executor = await (0, import_prompts.select)({
+      message: "Select a TypeScript executor",
+      choices: [
+        {
+          name: "Bun",
+          value: "bun",
+          description: "Fast all-in-one JavaScript runtime"
+        },
+        {
+          name: "TSX",
+          value: "tsx",
+          description: "TypeScript execute (tsx) - Node.js enhanced with esbuild"
+        }
+      ]
+    });
+    this.packageManager = this.executor === "bun" ? "bun" : await (0, import_prompts.select)({
+      message: "Select a package manager",
+      choices: [
+        {
+          name: "Yarn",
+          value: "yarn",
+          description: "Fast, reliable, and secure dependency management"
+        },
+        {
+          name: "npm",
+          value: "npm",
+          description: "Node package manager (default)"
+        },
+        {
+          name: "Bun",
+          value: "bun",
+          description: "Ultra-fast package manager built into Bun"
+        }
+      ],
+      default: "yarn"
+    });
+    (0, import_child_process.execSync)(`${this.packageManager} init -y`, {
+      stdio: "inherit",
+      cwd: this.projectPath
+    });
+    const packageJsonPath = import_path.default.join(this.projectPath, `package.json`);
+    let packageJson = JSON.parse(await fs.readFile(packageJsonPath, `utf-8`));
+    packageJson.type = "module";
+    packageJson.scripts = packageJson.scripts || {};
+    packageJson.scripts.prepare = "husky init";
+    packageJson.scripts.clean = "rm -rf dist";
+    if (this.executor === "bun") {
+      packageJson.scripts.dev = "bun run dev";
+      packageJson.scripts.start = "bun run pdev";
+      packageJson.scripts.build = "bun run build";
+      packageJson.scripts.test = "vitest";
+      packageJson.scripts["test:watch"] = "vitest --watch";
+      packageJson.scripts["test:coverage"] = "vitest run --coverage";
+    } else if (this.executor === "tsx") {
+      packageJson.scripts.dev = "tsx --watch -r tsconfig-paths/register src/index.ts start --all | npx pino-pretty";
+      packageJson.scripts.start = "tsx dist/index.js";
+      packageJson.scripts.build = "tsc";
+      packageJson.scripts.test = "vitest";
+      packageJson.scripts["test:watch"] = "vitest --watch";
+      packageJson.scripts["test:coverage"] = "vitest run --coverage";
+    }
+    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  }
+  async setupLinter() {
+    this.linter = await (0, import_prompts.select)({
+      message: "Select a linter",
+      choices: [
+        {
+          name: "Biome",
+          value: "biome",
+          description: "Fast formatter and linter for JavaScript, TypeScript, and more"
+        },
+        {
+          name: "ESLint",
+          value: "eslint",
+          description: "Find and fix problems in your JavaScript code"
+        }
+      ]
+    });
+    const packageJsonPath = import_path.default.join(this.projectPath, `package.json`);
+    let packageJson = JSON.parse(await fs.readFile(packageJsonPath, `utf-8`));
+    if (this.linter === "biome") {
+      packageJson.scripts.lint = "biome check . --ext .ts,.tsx";
+      packageJson.scripts.format = "biome format . --ext .ts,.tsx --write";
+      this.addPackage("@biomejs/biome", true);
+    } else if (this.linter === "eslint") {
+      packageJson.scripts.lint = "eslint . --ext .ts,.tsx";
+      packageJson.scripts.format = "eslint . --ext .ts,.tsx --fix";
+      this.addPackage("eslint", true);
     }
-    const validation_library = await (0, import_prompts.select)({
+    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  }
+  async setupGeneralPackages() {
+    this.validation_library = await (0, import_prompts.select)({
       message: "Select a package you want for validation",
       choices: [
         {
@@ -110,8 +237,42 @@ var CreateProjectCommand = class extends import_clipanion.Command {
         }
       ]
     });
-    await fs.mkdir(projectPath, { recursive: true });
-    console.log(`Created project directory at: ${projectPath}`);
+    this.validation_library === "none" || await this.addPackage(this.validation_library);
+    this.database_type = await (0, import_prompts.select)({
+      message: "Select a database type (you can add more databases later)",
+      choices: [
+        {
+          name: "PostgreSQL",
+          value: "postgresql",
+          description: "A powerful, open source object-relational database system"
+        },
+        {
+          name: "MySQL",
+          value: "mysql",
+          description: "The world's most popular open source database"
+        },
+        {
+          name: "SQLite",
+          value: "sqlite",
+          description: "A C library that provides a lightweight disk-based database"
+        }
+      ]
+    });
+    if (this.database_type === "postgresql") {
+      await this.addPackage("pg pg-cursor");
+    } else if (this.database_type === "mysql") {
+      await this.addPackage("mysql2");
+    } else if (this.database_type === "sqlite") {
+      await this.addPackage("sqlite3");
+    }
+    await this.addPackage("@devbro/pashmak tsconfig-paths dotenv ");
+    await this.addPackage(
+      "husky vitest supertest @types/supertest pino-pretty typescript tsx",
+      true
+    );
+  }
+  async setupBaseProject() {
+    console.log(`Using project directory: ${this.projectPath}`);
     const dirname = typeof __dirname === "undefined" ? import_path.default.dirname((0, import_url.fileURLToPath)(import_meta.url)) : __dirname;
     let basePath = import_path.default.join(dirname, `./base_project`);
     if (await this.folderExists(basePath) === false) {
@@ -119,53 +280,90 @@ var CreateProjectCommand = class extends import_clipanion.Command {
     }
     console.log(`Using base project path: ${basePath}`);
     const baseProjectPath = basePath;
-    await this.processTplFolder(baseProjectPath, projectPath, {
-      validation_library
+    await this.processTplFolder(baseProjectPath, this.projectPath, {
+      validation_library: this.validation_library,
+      executor: this.executor,
+      package_manager: this.packageManager,
+      linter: this.linter,
+      database_type: this.database_type
     });
-    console.log(`Copied base project files to: ${projectPath}`);
-    const packageJsonPath = import_path.default.join(projectPath, `package.json`);
-    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, `utf-8`));
-    packageJson.name = import_change_case_all.Case.snake(import_path.default.basename(projectPath));
+    console.log(`Copied base project files to: ${this.projectPath}`);
+    const packageJsonPath = import_path.default.join(this.projectPath, "package.json");
+    let packageJson = JSON.parse(await fs.readFile(packageJsonPath, `utf-8`));
+    packageJson.name = import_change_case_all.Case.snake(import_path.default.basename(this.projectPath));
     await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
     console.log(`Updated package.json with project name: ${packageJson.name}`);
-    if (this.git) {
-      try {
-        (0, import_child_process.execSync)(
-          'git init; git add --all; git commit --allow-empty -m "chore: first commit for pashmak"',
-          {
-            cwd: projectPath
-          }
-        );
-      } catch (error) {
-        console.error(`Failed to create project.`, error);
-        return 1;
-      }
+  }
+  async addPackage(packageName, dev = false) {
+    let install_command = "";
+    switch (this.packageManager) {
+      case "bun":
+        install_command = `bun add ${packageName}${dev ? " -d" : ""}`;
+        break;
+      case "yarn":
+        install_command = `yarn add ${packageName}${dev ? " -D" : ""} --no-install`;
+        break;
+      case "npm":
+        install_command = `npm install ${packageName}${dev ? " --save-dev" : ""} --package-lock-only`;
+        break;
     }
+    (0, import_child_process.execSync)(install_command, {
+      stdio: "inherit",
+      cwd: this.projectPath
+    });
   }
-  async processTplFolder(src, dest, data = {}) {
-    const files = await fs.readdir(src, { withFileTypes: true });
-    for (const file of files) {
-      const srcPath = import_path.default.join(src, file.name);
-      const destPath = file.isFile() && file.name.endsWith(".tpl") ? import_path.default.join(dest, file.name.substring(0, file.name.length - 4)) : import_path.default.join(dest, file.name);
-      if (file.isDirectory()) {
-        await fs.mkdir(destPath, { recursive: true });
-        await this.processTplFolder(srcPath, destPath, data);
-      } else if (file.name.endsWith(".tpl")) {
-        await this.processTplFile(srcPath, destPath, data);
-      } else {
-        throw new Error(
-          "unexpected non tpl file: " + srcPath + " " + file.name
-        );
-      }
+  async installPackages() {
+    const install_command = this.packageManager === "bun" ? `bun install` : this.packageManager === "yarn" ? `yarn` : `npm install`;
+    (0, import_child_process.execSync)(install_command, {
+      stdio: "inherit",
+      cwd: this.projectPath
+    });
+  }
+  async setupGit() {
+    const initGit = await (0, import_prompts.select)({
+      message: "Initialize a git repository?",
+      choices: [
+        {
+          name: "Yes",
+          value: true,
+          description: "Initialize git and create first commit"
+        },
+        {
+          name: "No",
+          value: false,
+          description: "Skip git initialization"
+        }
+      ]
+    });
+    if (initGit) {
+      const gitignoreContent = [
+        "node_modules/",
+        "dist/",
+        ".env",
+        ".env.*",
+        "!.env.example",
+        "*.log",
+        "coverage/",
+        ".DS_Store"
+      ].join("\n") + "\n";
+      await fs.writeFile(
+        import_path.default.join(this.projectPath, ".gitignore"),
+        gitignoreContent
+      );
+      (0, import_child_process.execSync)(
+        `git init; git add --all; git commit --allow-empty -m "chore: first commit"`,
+        {
+          cwd: this.projectPath
+        }
+      );
     }
   }
-  async processTplFile(src, dest, data = {}) {
-    import_handlebars.default.registerHelper("eq", (a, b) => a === b);
-    const compiledTemplate = import_handlebars.default.compile(
-      (await fs.readFile(src)).toString()
-    );
-    const template = await compiledTemplate(data);
-    await fs.writeFile(dest, template);
+  async catch(error) {
+    if (Error.isError(error)) {
+      console.error(error.message);
+    } else {
+      console.error(error);
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/app/console/project/base_project/src/config/caches.ts.tpl

@@ -1,5 +1,15 @@
 export default {
   default: {
-    type: 'disabled',
+    provider: 'disabled',
+    config: {},
+  },
+};
+
+export const $prod = {
+  default: {
+    provider: 'redis',
+    config: {
+      url: 'redis://redis:6379',
+    },
   },
 };

package/dist/cjs/app/console/project/base_project/src/config/databases.ts.tpl

@@ -1,10 +1,12 @@
 export default {
   default: {
-    host: process.env.DB_HOST,
-    database: process.env.DB_NAME || 'test_db',
-    user: process.env.DB_USER,
-    password: process.env.DB_PASSWORD,
-    port: parseInt(process.env.DB_PORT || '5432'),
-    name: 'db',
+    provider: 'postgresql',
+    config: {
+      host: process.env.DB_HOST,
+      database: process.env.DB_NAME || 'test_db',
+      user: process.env.DB_USER,
+      password: process.env.DB_PASSWORD,
+      port: parseInt(process.env.DB_PORT || '5432'),
+    },
   },
 };

package/dist/cjs/app/console/project/base_project/src/config/default.mts.tpl

@@ -3,18 +3,24 @@ import os from 'os';
 import { getEnv } from '@devbro/pashmak/helper';
 import { dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { loadConfig } from '@devbro/pashmak/config';
+import { loadConfigData, DotPaths } from '@devbro/pashmak/config';
+import * as databases_config from './databases';
+import * as storages_config from './storages';
+import * as mailers_config from './mailers';
+import * as queues_config from './queues';
+import * as caches_config from './caches';
+import * as loggers_config from './loggers';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const project_configs = {
-  databases: await loadConfig('./databases'),
-  storages: await loadConfig('./storages'),
-  mailer: await loadConfig('./mailer'),
-  loggers: await loadConfig('./loggers'),
-  queues: await loadConfig('./queues'),
-  caches: await loadConfig('./caches'),
+  databases: loadConfigData(databases_config),
+  storages: loadConfigData(storages_config),
+  mailer: loadConfigData(mailers_config),
+  loggers: loadConfigData(loggers_config),
+  queues: loadConfigData(queues_config),
+  caches: loadConfigData(caches_config),
   base_url: getEnv('BASE_URL', 'http://localhost:' + getEnv('PORT', '3000')),
   port: getEnv('PORT', 3000),
   file_upload_path: path.join(os.tmpdir(), ''),
@@ -43,19 +49,6 @@ export const $test = {
   // Test environment overrides
 };
 
-export const $prod = {
-  port: getEnv('PORT', 80),
-  debug_mode: false,
-};
-
-
-type DotPaths<T> = {
-  [K in keyof T & string]:
-    T[K] extends Record<string, any>
-      ? K | `${K}.${DotPaths<T[K]>}`
-      : K
-}[keyof T & string];
-
 declare module '@devbro/neko-config' {
     interface ConfigKeys extends Record<DotPaths<typeof project_configs>, string> {
     }

package/dist/cjs/app/console/project/base_project/src/config/loggers.ts.tpl

@@ -1,10 +1,20 @@
 import { ctxSafe } from '@devbro/pashmak/context';
-import { LogMessage } from '@devbro/pashmak/logger';
 
 export default {
   default: {
-    level: process.env.NODE_ENV === 'test' ? 'silent' : 'info',
-    extrasFunction: (message: LogMessage) => {
+    level: 'info',
+    extrasFunction: (message: any) => {
+      let requestId = ctxSafe()?.get('requestId');
+      requestId && (message.requestId = requestId);
+      return message;
+    },
+  },
+};
+
+export const $test = {
+  default: {
+    level: 'silent',
+    extrasFunction: (message: any) => {
       let requestId = ctxSafe()?.get('requestId');
       requestId && (message.requestId = requestId);
       return message;

package/dist/cjs/app/console/project/base_project/src/config/storages.ts.tpl

@@ -1,4 +1,3 @@
-import { LocalStorageProviderConfig } from '@devbro/pashmak/storage';
 import path from 'path';
 import os from 'os';
 
@@ -7,6 +6,6 @@ export default {
     provider: 'local',
     config: {
       basePath: path.join(os.tmpdir(), '/app-storage/'),
-    } as LocalStorageProviderConfig,
+    },
   },
 };

package/dist/cjs/app/console/project/base_project/src/initialize.ts.tpl

@@ -1,24 +1,56 @@
-import dotenv from 'dotenv';
+import dotenv from "dotenv";
 dotenv.config();
 
-import { bootstrap } from '@devbro/pashmak';
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { loadConfig } from '@devbro/pashmak/config';
-import { httpServer, logger, mailer } from '@devbro/pashmak/facades';
-import { startQueueListeners } from '@/app/queues';
-import { HttpError } from '@devbro/pashmak/http';
-{{#if (eq validation_library "yup")}}import * as yup from 'yup';{{/if}}{{#if (eq validation_library "zod")}}import { z, ZodError } from 'zod';{{/if}}
+import { config, loadConfigData } from "@devbro/pashmak/config";
+import * as config_data from "./config/default.mts";
+await config.load(loadConfigData(config_data));
 
-import './app/console';
-import './routes';
-import './schedules';
+import { httpServer, logger } from "@devbro/pashmak/facades";
+import { startQueueListeners } from "@/app/queues";
+import { HttpError } from "@devbro/pashmak/http";
 
-const config_data = await loadConfig(dirname(fileURLToPath(import.meta.url)) + '/config/default');
+import * as yup from "yup";
+import { Request, Response, Middleware } from "@devbro/neko-router";
+import { DatabaseProviderMiddleware } from "@devbro/pashmak/middlewares";
 
-await bootstrap({
-  root_dir: dirname(fileURLToPath(import.meta.url)),
-  config_data,
+import "@devbro/pashmak";
+
+import "./app/console";
+import "./routes";
+import "./schedules";
+
+import { context_provider } from "@devbro/neko-context";
+
+import { Connection } from "@devbro/neko-sql";
+import { Global } from "@devbro/pashmak/global";
+import { ctx } from "@devbro/pashmak/context";
+import { BaseModel } from "@devbro/pashmak/orm";
+
+context_provider.setPreLoader(async (f: Function) => {
+	const middlewares: Middleware[] = [];
+	const m = DatabaseProviderMiddleware.getInstance();
+	middlewares.push(m);
+
+	await m.call({} as Request, {} as Response, f as () => Promise<void>);
+});
+
+Global.set(
+	"database.default",
+	DatabaseProviderMiddleware.getInstance().getConnection(
+		config.get("databases.default") as any,
+	),
+);
+
+BaseModel.setConnection(() => {
+	const key = ["database", "default"];
+	let rc: Connection | undefined;
+
+	if (ctx.isActive()) {
+		rc = ctx().get<Connection>(key);
+	} else if (Global.has(key)) {
+		rc = Global.get<Connection>(key);
+	}
+	return rc!;
 });
 
 httpServer().setErrorHandler(async (err: Error, req: any, res: any) => {

package/dist/cjs/app/console/project/base_project/src/routes.ts.tpl

@@ -9,9 +9,9 @@ const router = routerFunc();
 router.addGlobalMiddleware(loggerMiddleware);
 router.addRoute(
   ["GET", "HEAD"],
-  "/api/v1/meow",
+  "/",
   async (req: any, res: any) => {
-    return { message: "meow meow!" };
+    return { message: "Welcome to Pashmak!" };
   },
 ).addMiddleware([]);