@gaman/kame 0.1.0

package/dist/commands/registry.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var registry_exports = {};
+__export(registry_exports, {
+  Command: () => Command,
+  getAllCommands: () => getAllCommands,
+  getCommand: () => getCommand,
+  registerCommand: () => registerCommand
+});
+module.exports = __toCommonJS(registry_exports);
+class Command {
+  _name;
+  _handler;
+  _description = "";
+  _usage = "";
+  _aliases = [];
+  constructor(name, handler) {
+    this._name = name, this._handler = handler;
+  }
+  description(description) {
+    return this._description = description, this;
+  }
+  usage(usage) {
+    return this._usage = usage, this;
+  }
+  aliases(aliases2) {
+    return this._aliases = aliases2, this;
+  }
+  getName() {
+    return this._name;
+  }
+  getHandler() {
+    return this._handler;
+  }
+  getDescription() {
+    return this._description;
+  }
+  getUsage() {
+    return this._usage;
+  }
+  getAliases() {
+    return this._aliases;
+  }
+}
+const commands = /* @__PURE__ */ new Map(), aliases = /* @__PURE__ */ new Map(), registerCommand = (cmd) => {
+  let _cmd;
+  cmd instanceof Command ? _cmd = cmd : _cmd = new Command(cmd.name, cmd.handler).description(cmd.description ?? "").usage(cmd.usage ?? "").aliases(cmd.aliases ?? []), commands.set(_cmd.getName(), _cmd);
+  for (const alias of _cmd.getAliases())
+    aliases.set(alias, _cmd.getName());
+}, getCommand = (name) => {
+  const cmd = commands.get(name);
+  if (cmd) return cmd;
+  const aliasCmdName = aliases.get(name);
+  if (aliasCmdName) return commands.get(aliasCmdName);
+}, getAllCommands = () => Array.from(commands.values());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Command,
+  getAllCommands,
+  getCommand,
+  registerCommand
+});

package/dist/commands/registry.mjs

@@ -0,0 +1,51 @@
+class Command {
+  _name;
+  _handler;
+  _description = "";
+  _usage = "";
+  _aliases = [];
+  constructor(name, handler) {
+    this._name = name, this._handler = handler;
+  }
+  description(description) {
+    return this._description = description, this;
+  }
+  usage(usage) {
+    return this._usage = usage, this;
+  }
+  aliases(aliases2) {
+    return this._aliases = aliases2, this;
+  }
+  getName() {
+    return this._name;
+  }
+  getHandler() {
+    return this._handler;
+  }
+  getDescription() {
+    return this._description;
+  }
+  getUsage() {
+    return this._usage;
+  }
+  getAliases() {
+    return this._aliases;
+  }
+}
+const commands = /* @__PURE__ */ new Map(), aliases = /* @__PURE__ */ new Map(), registerCommand = (cmd) => {
+  let _cmd;
+  cmd instanceof Command ? _cmd = cmd : _cmd = new Command(cmd.name, cmd.handler).description(cmd.description ?? "").usage(cmd.usage ?? "").aliases(cmd.aliases ?? []), commands.set(_cmd.getName(), _cmd);
+  for (const alias of _cmd.getAliases())
+    aliases.set(alias, _cmd.getName());
+}, getCommand = (name) => {
+  const cmd = commands.get(name);
+  if (cmd) return cmd;
+  const aliasCmdName = aliases.get(name);
+  if (aliasCmdName) return commands.get(aliasCmdName);
+}, getAllCommands = () => Array.from(commands.values());
+export {
+  Command,
+  getAllCommands,
+  getCommand,
+  registerCommand
+};

package/dist/compose/index.d.ts

@@ -0,0 +1,5 @@
+import { Command, type CommandHandler } from '../commands/registry';
+export interface KameConsole {
+    command(name: string, handler: CommandHandler): Command;
+}
+export declare function composeConsole(handler: (kame: KameConsole) => Promise<void> | void): void;

package/dist/compose/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var compose_exports = {};
+__export(compose_exports, {
+  composeConsole: () => composeConsole
+});
+module.exports = __toCommonJS(compose_exports);
+var import_registry = require('../commands/registry.js');
+function composeConsole(handler) {
+  handler({
+    command(name, handler2) {
+      const cmdClass = new import_registry.Command(name, handler2);
+      return (0, import_registry.registerCommand)(cmdClass), cmdClass;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  composeConsole
+});

package/dist/compose/index.mjs

@@ -0,0 +1,15 @@
+import {
+  Command,
+  registerCommand
+} from "../commands/registry.mjs";
+function composeConsole(handler) {
+  handler({
+    command(name, handler2) {
+      const cmdClass = new Command(name, handler2);
+      return registerCommand(cmdClass), cmdClass;
+    }
+  });
+}
+export {
+  composeConsole
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { startKame } from './repl';
+import { Gaman } from 'gaman';
+export declare function startKameWithGaman(gaman: Gaman): void;

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var index_exports = {};
+__export(index_exports, {
+  startKame: () => import_repl.startKame,
+  startKameWithGaman: () => startKameWithGaman
+});
+module.exports = __toCommonJS(index_exports);
+var import_repl = require('./repl.js'), import_gaman = require('gaman'), import_repl2 = require('./repl.js');
+function startKameWithGaman(gaman) {
+  return (0, import_repl2.startKame)();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startKame,
+  startKameWithGaman
+});

package/dist/index.mjs

@@ -0,0 +1,10 @@
+import { startKame } from "./repl.mjs";
+import { Gaman } from 'gaman';
+import { startKame as startKame2 } from "./repl.mjs";
+function startKameWithGaman(gaman) {
+  return startKame2();
+}
+export {
+  startKame,
+  startKameWithGaman
+};

package/dist/input-parser.d.ts

@@ -0,0 +1,5 @@
+export interface ParsedInput {
+    args: string[];
+    flags: Record<string, string | boolean>;
+}
+export declare function parseInput(argv: string[]): ParsedInput;

package/dist/input-parser.js

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var input_parser_exports = {};
+__export(input_parser_exports, {
+  parseInput: () => parseInput
+});
+module.exports = __toCommonJS(input_parser_exports);
+function parseInput(argv) {
+  const args = [], flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token !== void 0)
+      if (token.startsWith("--")) {
+        const key = token.slice(2), next = argv[i + 1];
+        !next || next.startsWith("--") || next.startsWith("-") ? flags[key] = !0 : (flags[key] = next, i++);
+      } else if (token.startsWith("-") && token.length === 2) {
+        const key = token.slice(1), next = argv[i + 1];
+        !next || next.startsWith("--") || next.startsWith("-") ? flags[key] = !0 : (flags[key] = next, i++);
+      } else
+        args.push(token);
+  }
+  return { args, flags };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseInput
+});

package/dist/input-parser.mjs

@@ -0,0 +1,19 @@
+function parseInput(argv) {
+  const args = [], flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token !== void 0)
+      if (token.startsWith("--")) {
+        const key = token.slice(2), next = argv[i + 1];
+        !next || next.startsWith("--") || next.startsWith("-") ? flags[key] = !0 : (flags[key] = next, i++);
+      } else if (token.startsWith("-") && token.length === 2) {
+        const key = token.slice(1), next = argv[i + 1];
+        !next || next.startsWith("--") || next.startsWith("-") ? flags[key] = !0 : (flags[key] = next, i++);
+      } else
+        args.push(token);
+  }
+  return { args, flags };
+}
+export {
+  parseInput
+};

package/dist/repl.d.ts

@@ -0,0 +1,9 @@
+import './commands/gen-module';
+import './commands/gen-router';
+import './commands/gen-controller';
+import './commands/gen-service';
+import './commands/gen-middleware';
+import './commands/gen-exception';
+import './commands/buntest-cmd';
+import './commands/fetch';
+export declare function startKame(): void;

package/dist/repl.js

@@ -0,0 +1,63 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var repl_exports = {};
+__export(repl_exports, {
+  startKame: () => startKame
+});
+module.exports = __toCommonJS(repl_exports);
+var readline = __toESM(require("node:readline")), import_utils = require('gaman/utils'), import_registry = require('./commands/registry.js'), import_input_parser = require('./input-parser.js'), import_gen_module = require('./commands/gen-module.js'), import_gen_router = require('./commands/gen-router.js'), import_gen_controller = require('./commands/gen-controller.js'), import_gen_service = require('./commands/gen-service.js'), import_gen_middleware = require('./commands/gen-middleware.js'), import_gen_exception = require('./commands/gen-exception.js'), import_buntest_cmd = require('./commands/buntest-cmd.js'), import_fetch = require('./commands/fetch.js');
+function startKame() {
+  if (!process.env.KAME_CLI) return;
+  import_utils.Logger.info(
+    `${import_utils.TextFormat.BG_CYAN} ${import_utils.TextFormat.BOLD}Kame ${import_utils.TextFormat.RESET} System active. Type "help" for commands.`
+  );
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: !0
+  });
+  rl.setPrompt("> "), rl.prompt(), rl.write("help"), rl.on("line", async (line) => {
+    const _argv = line.trim().split(" "), commandName = _argv[0];
+    if (commandName === void 0) return;
+    const { args, flags } = (0, import_input_parser.parseInput)(_argv.slice(1));
+    if (commandName === "help") {
+      const commands = (0, import_registry.getAllCommands)();
+      import_utils.Logger.info(`${import_utils.TextFormat.BOLD}Available commands:${import_utils.TextFormat.RESET}`);
+      for (const cmd2 of commands)
+        import_utils.Logger.info(
+          `${import_utils.TextFormat.YELLOW}- ${import_utils.TextFormat.RESET}${cmd2.getUsage().padEnd(40)}  ${import_utils.TextFormat.GRAY}${cmd2.getDescription()}${import_utils.TextFormat.RESET}`
+        );
+      rl.prompt();
+      return;
+    }
+    const cmd = (0, import_registry.getCommand)(commandName);
+    cmd ? await cmd.getHandler()(args, flags) : import_utils.Logger.error(
+      `Unknown command: "${commandName}". Run "help" to see available commands.`
+    ), rl.prompt();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startKame
+});

package/dist/repl.mjs

@@ -0,0 +1,45 @@
+import * as readline from "node:readline";
+import { Logger, TextFormat } from 'gaman/utils';
+import { getAllCommands, getCommand } from "./commands/registry.mjs";
+import { parseInput } from "./input-parser.mjs";
+import "./commands/gen-module";
+import "./commands/gen-router";
+import "./commands/gen-controller";
+import "./commands/gen-service";
+import "./commands/gen-middleware";
+import "./commands/gen-exception";
+import "./commands/buntest-cmd";
+import "./commands/fetch";
+function startKame() {
+  if (!process.env.KAME_CLI) return;
+  Logger.info(
+    `${TextFormat.BG_CYAN} ${TextFormat.BOLD}Kame ${TextFormat.RESET} System active. Type "help" for commands.`
+  );
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: !0
+  });
+  rl.setPrompt("> "), rl.prompt(), rl.write("help"), rl.on("line", async (line) => {
+    const _argv = line.trim().split(" "), commandName = _argv[0];
+    if (commandName === void 0) return;
+    const { args, flags } = parseInput(_argv.slice(1));
+    if (commandName === "help") {
+      const commands = getAllCommands();
+      Logger.info(`${TextFormat.BOLD}Available commands:${TextFormat.RESET}`);
+      for (const cmd2 of commands)
+        Logger.info(
+          `${TextFormat.YELLOW}- ${TextFormat.RESET}${cmd2.getUsage().padEnd(40)}  ${TextFormat.GRAY}${cmd2.getDescription()}${TextFormat.RESET}`
+        );
+      rl.prompt();
+      return;
+    }
+    const cmd = getCommand(commandName);
+    cmd ? await cmd.getHandler()(args, flags) : Logger.error(
+      `Unknown command: "${commandName}". Run "help" to see available commands.`
+    ), rl.prompt();
+  });
+}
+export {
+  startKame
+};

package/dist/templates/module.d.ts

@@ -0,0 +1,6 @@
+export declare const serviceTemplate: (name: string) => string;
+export declare const controllerTemplate: (name: string) => string;
+export declare const routerTemplate: (name: string) => string;
+export declare const routerBlankTemplate: () => string;
+export declare const middlewareTemplate: () => string;
+export declare const exceptionTemplate: () => string;

package/dist/templates/module.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var module_exports = {};
+__export(module_exports, {
+  controllerTemplate: () => controllerTemplate,
+  exceptionTemplate: () => exceptionTemplate,
+  middlewareTemplate: () => middlewareTemplate,
+  routerBlankTemplate: () => routerBlankTemplate,
+  routerTemplate: () => routerTemplate,
+  serviceTemplate: () => serviceTemplate
+});
+module.exports = __toCommonJS(module_exports);
+var import_utils = require('../utils.js');
+const serviceTemplate = (name) => {
+  const nameCapitalized = (0, import_utils.capitalize)(name);
+  return `
+import { composeService } from './../compose/index.ts';
+import type { RT } from './../types.ts';
+
+export const ${nameCapitalized}Service = composeService(() => {
+	
+	// TODO: Implement your service logic here
+
+	return {
+		WelcomeMessage() {
+			return 'Welcome to ${nameCapitalized} Service!';
+		},
+	};
+});
+
+export type ${nameCapitalized}Service = RT<typeof ${nameCapitalized}Service>;
+`.trim();
+}, controllerTemplate = (name) => {
+  const nameCapitalized = (0, import_utils.capitalize)(name);
+  return `
+import { composeController } from './../compose/index.ts';
+import { Res } from './../responder.ts';
+import { ${nameCapitalized}Service } from '../services/${nameCapitalized}Service';
+
+export type Deps = {
+	${(0, import_utils.toCamelCase)(name)}Service: ${nameCapitalized}Service;
+}
+	
+export default composeController(({ ${(0, import_utils.toCamelCase)(name)}Service }: Deps) => {
+	
+	// TODO: Implement your controller logic here
+
+	return {
+		index(ctx) {
+			return Res.json({
+				message: ${(0, import_utils.toCamelCase)(name)}Service.WelcomeMessage(),
+			});
+		},
+	};
+});
+`.trim();
+}, routerTemplate = (name) => {
+  const nameCapitalized = (0, import_utils.capitalize)(name), camelCaseName = (0, import_utils.toCamelCase)(name);
+  return `
+import { composeRouter } from './../compose/index.ts';
+import ${nameCapitalized}Controller from './controllers/${nameCapitalized}Controller';
+import { ${nameCapitalized}Service } from './services/${nameCapitalized}Service';
+
+export default composeRouter((r) => {
+	r.mountService({
+		${camelCaseName}Service: ${nameCapitalized}Service(),
+	});
+  
+  r.get('/', [${nameCapitalized}Controller, 'index']);
+});
+`.trim();
+}, routerBlankTemplate = () => `
+import { composeRouter } from './../compose/index.ts';
+
+export default composeRouter((r) => {
+	r.mountService({
+		
+	});
+	
+	// TODO: Implement your routers
+});
+`.trim(), middlewareTemplate = () => `
+import { composeMiddleware } from './../compose/index.ts';
+
+export default composeMiddleware(async (ctx, next) => {
+
+	// TODO: Implement your middleware logic here
+
+	return next();
+});
+`.trim(), exceptionTemplate = () => `
+import { composeException } from './../compose/index.ts';
+import { Res } from './../responder.ts';
+
+export default composeException((err, ctx) => {
+	
+	// TODO: Implement your exception handler logic here
+
+	return Res.internalServerError();
+});
+	`.trim();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  controllerTemplate,
+  exceptionTemplate,
+  middlewareTemplate,
+  routerBlankTemplate,
+  routerTemplate,
+  serviceTemplate
+});

package/dist/templates/module.mjs

@@ -0,0 +1,97 @@
+import { capitalize, toCamelCase } from "../utils.mjs";
+const serviceTemplate = (name) => {
+  const nameCapitalized = capitalize(name);
+  return `
+import { composeService } from 'gaman/compose';
+import type { RT } from 'gaman/types';
+
+export const ${nameCapitalized}Service = composeService(() => {
+	
+	// TODO: Implement your service logic here
+
+	return {
+		WelcomeMessage() {
+			return 'Welcome to ${nameCapitalized} Service!';
+		},
+	};
+});
+
+export type ${nameCapitalized}Service = RT<typeof ${nameCapitalized}Service>;
+`.trim();
+}, controllerTemplate = (name) => {
+  const nameCapitalized = capitalize(name);
+  return `
+import { composeController } from 'gaman/compose';
+import { Res } from 'gaman/responder';
+import { ${nameCapitalized}Service } from '../services/${nameCapitalized}Service.mjs';
+
+export type Deps = {
+	${toCamelCase(name)}Service: ${nameCapitalized}Service;
+}
+	
+export default composeController(({ ${toCamelCase(name)}Service }: Deps) => {
+	
+	// TODO: Implement your controller logic here
+
+	return {
+		index(ctx) {
+			return Res.json({
+				message: ${toCamelCase(name)}Service.WelcomeMessage(),
+			});
+		},
+	};
+});
+`.trim();
+}, routerTemplate = (name) => {
+  const nameCapitalized = capitalize(name), camelCaseName = toCamelCase(name);
+  return `
+import { composeRouter } from 'gaman/compose';
+import ${nameCapitalized}Controller from './controllers/${nameCapitalized}Controller.mjs';
+import { ${nameCapitalized}Service } from './services/${nameCapitalized}Service.mjs';
+
+export default composeRouter((r) => {
+	r.mountService({
+		${camelCaseName}Service: ${nameCapitalized}Service(),
+	});
+  
+  r.get('/', [${nameCapitalized}Controller, 'index']);
+});
+`.trim();
+}, routerBlankTemplate = () => `
+import { composeRouter } from 'gaman/compose';
+
+export default composeRouter((r) => {
+	r.mountService({
+		
+	});
+	
+	// TODO: Implement your routers
+});
+`.trim(), middlewareTemplate = () => `
+import { composeMiddleware } from 'gaman/compose';
+
+export default composeMiddleware(async (ctx, next) => {
+
+	// TODO: Implement your middleware logic here
+
+	return next();
+});
+`.trim(), exceptionTemplate = () => `
+import { composeException } from 'gaman/compose';
+import { Res } from 'gaman/responder';
+
+export default composeException((err, ctx) => {
+	
+	// TODO: Implement your exception handler logic here
+
+	return Res.internalServerError();
+});
+	`.trim();
+export {
+  controllerTemplate,
+  exceptionTemplate,
+  middlewareTemplate,
+  routerBlankTemplate,
+  routerTemplate,
+  serviceTemplate
+};

package/dist/templates/service.d.ts

@@ -0,0 +1 @@
+export declare const standaloneServiceTemplate: (name: string) => string;