lumen-framework 3.0.0

package/dist/cli.cjs

@@ -0,0 +1,3002 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__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: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/packages/cli/commands/index.ts
+var index_exports = {};
+__export(index_exports, {
+  build: () => build2,
+  create: () => create2,
+  dbcreate: () => dbcreate,
+  dbdrop: () => dbdrop,
+  dbmigrate: () => dbmigrate,
+  dbrollback: () => dbrollback,
+  dbseed: () => dbseed,
+  destroy: () => destroy2,
+  generate: () => generate,
+  repl: () => repl,
+  serve: () => serve,
+  test: () => test
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/packages/cli/commands/build.ts
+var import_ora = __toESM(require("ora"));
+
+// src/constants.ts
+var import_os = require("os");
+var { env: ENV } = process;
+var CWD = process.cwd();
+var PID = process.pid;
+var PORT = parseInt(ENV.PORT, 10) || 4e3;
+var NODE_ENV = ENV.NODE_ENV || "development";
+var DATABASE_URL = ENV.DATABASE_URL;
+var LUMEN_CONSOLE = ENV.LUMEN_CONSOLE || false;
+var PLATFORM = (0, import_os.platform)();
+
+// src/packages/compiler/index.ts
+var import_path9 = __toESM(require("path"));
+var esbuild = __toESM(require("esbuild"));
+
+// src/packages/fs/index.ts
+var import_fs2 = __toESM(require("fs"));
+var import_path5 = require("path");
+
+// src/packages/fs/watcher/index.ts
+var import_events = __toESM(require("events"));
+var import_fb_watchman2 = require("fb-watchman");
+
+// src/packages/fs/watcher/initialize.ts
+var import_path2 = require("path");
+var import_fs = require("fs");
+var import_fb_watchman = require("fb-watchman");
+
+// src/utils/exec.ts
+var import_child_process = require("child_process");
+function exec(cmd, opts) {
+  return new Promise((resolve2, reject) => {
+    (0, import_child_process.exec)(cmd, { ...opts, encoding: "utf8" }, (err, stdout, stderr) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve2([stdout, stderr]);
+    });
+  });
+}
+
+// src/utils/k.ts
+function K() {
+  return this;
+}
+
+// src/utils/try-catch.ts
+async function tryCatch(fn, rescue = K) {
+  let result;
+  try {
+    result = await fn();
+  } catch (err) {
+    result = await rescue(err);
+  }
+  return result;
+}
+
+// src/packages/fs/utils/is-js-file.ts
+var import_path = require("path");
+function isJSFile(target) {
+  return (0, import_path.extname)(target) === ".js";
+}
+
+// src/packages/freezeable/constants.ts
+var FREEZER = /* @__PURE__ */ new WeakSet();
+
+// src/utils/is-object.ts
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/packages/freezeable/utils/freeze.ts
+function freeze(value) {
+  FREEZER.add(value);
+  return value;
+}
+function freezeProps(target, makePublic, ...props) {
+  Object.defineProperties(
+    target,
+    props.reduce(
+      (obj, key) => ({
+        ...obj,
+        [key]: {
+          value: Reflect.get(target, key),
+          writable: false,
+          enumerable: makePublic,
+          configurable: false
+        }
+      }),
+      {}
+    )
+  );
+  return target;
+}
+
+// src/packages/freezeable/utils/is-frozen.ts
+function isFrozen(value) {
+  return FREEZER.has(value);
+}
+
+// src/packages/freezeable/map/index.ts
+var FreezeableMap = class extends Map {
+  set(key, value) {
+    if (!this.isFrozen()) {
+      super.set(key, value);
+    }
+    return this;
+  }
+  clear() {
+    if (!this.isFrozen()) {
+      super.clear();
+    }
+  }
+  delete(key) {
+    return this.isFrozen() ? false : super.delete(key);
+  }
+  freeze(deep) {
+    if (deep) {
+      this.forEach(Object.freeze);
+    }
+    return freeze(this);
+  }
+  isFrozen() {
+    return isFrozen(this);
+  }
+};
+var map_default = FreezeableMap;
+
+// src/packages/freezeable/set/index.ts
+var FreezeableSet = class extends Set {
+  add(value) {
+    if (!this.isFrozen()) {
+      super.add(value);
+    }
+    return this;
+  }
+  clear() {
+    if (!this.isFrozen()) {
+      super.clear();
+    }
+  }
+  delete(value) {
+    return this.isFrozen() ? false : super.delete(value);
+  }
+  freeze(deep) {
+    if (deep) {
+      this.forEach(Object.freeze);
+    }
+    return freeze(this);
+  }
+  isFrozen() {
+    return isFrozen(this);
+  }
+};
+var set_default = FreezeableSet;
+
+// src/packages/fs/watcher/initialize.ts
+var SUBSCRIPTION_NAME = "lumen-watcher";
+function fallback(instance, path6) {
+  return (0, import_fs.watch)(
+    path6,
+    {
+      recursive: true
+    },
+    (type, name) => {
+      if (typeof name === "string" && isJSFile(name)) {
+        instance.emit("change", [{ name, type }]);
+      }
+    }
+  );
+}
+function setupWatchmen(instance, path6) {
+  return new Promise((resolve2, reject) => {
+    const client = new import_fb_watchman.Client();
+    client.capabilityCheck({}, (capabilityErr) => {
+      if (capabilityErr) {
+        reject(capabilityErr);
+        return;
+      }
+      client.command(
+        ["watch-project", path6],
+        (watchErr, { watch: watch2, relative_path: relativePath } = {}) => {
+          if (watchErr) {
+            reject(watchErr);
+            return;
+          }
+          client.command(["clock", watch2], (clockErr, { clock: since }) => {
+            if (clockErr) {
+              reject(clockErr);
+              return;
+            }
+            client.command(
+              [
+                "subscribe",
+                watch2,
+                SUBSCRIPTION_NAME,
+                {
+                  since,
+                  relative_root: relativePath,
+                  fields: ["name", "size", "exists", "type"],
+                  expression: ["allof", ["match", "*.js"]]
+                }
+              ],
+              (subscribeErr) => {
+                if (subscribeErr) {
+                  reject(subscribeErr);
+                  return;
+                }
+                client.on("subscription", ({ files, subscription }) => {
+                  if (subscription === SUBSCRIPTION_NAME) {
+                    instance.emit("change", files);
+                  }
+                });
+                resolve2(client);
+              }
+            );
+          });
+        }
+      );
+    });
+  });
+}
+async function initialize(instance, path6, useWatchman) {
+  const appPath = (0, import_path2.join)(path6, "app");
+  let client;
+  if (useWatchman) {
+    await tryCatch(async () => {
+      await exec("which watchman");
+      client = await setupWatchmen(instance, appPath);
+    });
+  }
+  Object.assign(instance, {
+    path: appPath,
+    client: client || fallback(instance, appPath)
+  });
+  freezeProps(instance, true, "path", "client");
+  return instance;
+}
+
+// src/packages/fs/watcher/index.ts
+var Watcher = class extends import_events.default {
+  constructor(path6, useWatchman = true) {
+    super();
+    return initialize(this, path6, useWatchman);
+  }
+  destroy() {
+    const { client } = this;
+    if (client instanceof import_fb_watchman2.Client) {
+      client.end();
+    } else {
+      client.close();
+    }
+  }
+};
+var watcher_default = Watcher;
+
+// src/packages/fs/utils/create-resolver.ts
+function createResolver(resolve2, reject) {
+  return function fsResolver(err, ...args) {
+    const [data] = args;
+    if (err) {
+      reject(err);
+      return;
+    }
+    resolve2(args.length > 1 ? args : data);
+  };
+}
+
+// src/packages/fs/utils/create-path-remover.ts
+function createPathRemover(path6) {
+  let pattern = new RegExp(`${path6}(/)?(.+)`);
+  if (PLATFORM.startsWith("win")) {
+    const sep2 = "\\\\";
+    pattern = new RegExp(`${path6.replace(/\\/g, sep2)}(${sep2})?(.+)`);
+  }
+  return (source) => source.replace(pattern, "$2");
+}
+var create_path_remover_default = createPathRemover;
+
+// src/packages/fs/utils/rmrf.ts
+var import_path3 = __toESM(require("path"));
+function rmrf(target) {
+  return stat(target).then((stats) => {
+    if (stats && stats.isDirectory()) {
+      return readdir(target);
+    } else if (stats && stats.isFile()) {
+      return unlink(target).then(() => []);
+    }
+    return [];
+  }).then(
+    (files) => Promise.all(files.map((file) => rmrf(import_path3.default.join(target, file))))
+  ).then(() => rmdir(target)).catch((err) => {
+    if (err.code === "ENOENT") {
+      return Promise.resolve();
+    }
+    return Promise.reject(err);
+  }).then(() => true);
+}
+var rmrf_default = rmrf;
+
+// src/packages/fs/utils/exists.ts
+async function exists(path6, dir) {
+  if (path6 instanceof RegExp) {
+    const pattern = path6;
+    let files = [];
+    if (dir) {
+      files = await readdir(dir);
+    }
+    return files.some((file) => pattern.test(file));
+  }
+  return stat(path6).then(
+    () => true,
+    () => false
+  );
+}
+
+// src/packages/fs/utils/parse-path.ts
+var import_path4 = __toESM(require("path"));
+
+// src/utils/chain.ts
+function chain(source) {
+  return {
+    pipe(handler) {
+      return chain(handler(source));
+    },
+    value() {
+      return source;
+    },
+    construct(constructor) {
+      return chain(Reflect.construct(constructor, [source]));
+    }
+  };
+}
+
+// src/packages/fs/utils/parse-path.ts
+function resolvePath(cwd = CWD, dir = "", name = "") {
+  return chain(name.split("/")).pipe((parts) => import_path4.default.join(cwd, dir, ...parts)).pipe(import_path4.default.parse).pipe(({ base, ...etc }) => ({
+    base,
+    ...etc,
+    relative: import_path4.default.join(etc.dir.substr(etc.dir.indexOf(dir)), base),
+    absolute: import_path4.default.join(etc.dir, base)
+  })).value();
+}
+
+// src/packages/fs/index.ts
+function watch(path6) {
+  return new watcher_default(path6);
+}
+function stat(path6) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.stat(path6, createResolver(resolve2, reject));
+  });
+}
+function mkdir(path6, mode = 511) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.mkdir(path6, mode, createResolver(resolve2, reject));
+  });
+}
+function mkdirRec(path6, mode = 511) {
+  const parent = (0, import_path5.resolve)(path6, "..");
+  return stat(parent).catch((err) => {
+    if (err.code === "ENOENT") {
+      return mkdirRec(parent, mode);
+    }
+    return Promise.reject(err);
+  }).then(() => mkdir(path6, mode)).catch((err) => {
+    if (err.code !== "EEXIST") {
+      return Promise.reject(err);
+    }
+    return Promise.resolve();
+  });
+}
+function rmdir(path6) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.rmdir(path6, createResolver(resolve2, reject));
+  });
+}
+function readdir(path6, opts) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.readdir(path6, createResolver(resolve2, reject));
+  });
+}
+function readdirRec(path6, opts) {
+  const stripPath = create_path_remover_default(path6);
+  return readdir(path6, opts).then(
+    (files) => Promise.all(
+      files.map((file) => {
+        const filePath = (0, import_path5.join)(path6, file);
+        return Promise.all([filePath, stat(filePath)]);
+      })
+    )
+  ).then(
+    (files) => Promise.all(
+      files.map(
+        ([file, stats]) => Promise.all([file, stats.isDirectory() ? readdirRec(file) : []])
+      )
+    )
+  ).then(
+    (files) => files.reduce((arr, [file, children]) => {
+      const basename3 = stripPath(file);
+      return [
+        ...arr,
+        basename3,
+        ...children.map((child) => (0, import_path5.join)(basename3, stripPath(child)))
+      ];
+    }, [])
+  );
+}
+function readFile(path6, opts) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.readFile(
+      path6,
+      typeof opts === "object" ? opts : {},
+      createResolver(resolve2, reject)
+    );
+  });
+}
+function writeFile(path6, data, opts) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.writeFile(
+      path6,
+      data,
+      opts || {},
+      createResolver(resolve2, reject)
+    );
+  });
+}
+function appendFile(path6, data, opts) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.appendFile(
+      path6,
+      data,
+      typeof opts === "object" ? opts : {},
+      createResolver(resolve2, reject)
+    );
+  });
+}
+function unlink(path6) {
+  return new Promise((resolve2, reject) => {
+    import_fs2.default.unlink(path6, createResolver(resolve2, reject));
+  });
+}
+
+// src/packages/compiler/utils/create-manifest.ts
+var import_path7 = require("path");
+var import_inflection3 = require("inflection");
+
+// src/utils/underscore.ts
+var import_inflection = require("inflection");
+function underscore(source = "", upper = false) {
+  return (0, import_inflection.underscore)(source, upper).replace(/-/g, "_");
+}
+
+// src/utils/compose.ts
+function compose(main, ...etc) {
+  return (input) => main(etc.reduceRight((value, fn) => fn(value), input));
+}
+function composeAsync(main, ...etc) {
+  return (input) => etc.reduceRight(
+    (value, fn) => Promise.resolve(value).then(fn),
+    Promise.resolve(input)
+  ).then(main);
+}
+
+// src/packages/compiler/utils/format-name.ts
+var import_path6 = require("path");
+var import_inflection2 = require("inflection");
+var DOUBLE_COLON = /::/g;
+var formatName = compose(
+  (name) => name.replace(DOUBLE_COLON, "$"),
+  import_inflection2.camelize,
+  underscore,
+  (name) => import_path6.posix.join((0, import_path6.dirname)(name), (0, import_path6.basename)(name, ".js"))
+);
+var format_name_default = formatName;
+
+// src/packages/compiler/utils/create-manifest.ts
+function createExportStatement(name, path6, isDefault = true) {
+  const normalized = import_path7.posix.join(...path6.split(import_path7.sep));
+  if (isDefault) {
+    return `export {
+  default as ${name}
+} from '../${normalized}';
+
+`;
+  }
+  return `export {
+  ${name}
+} from '../${normalized}';
+
+`;
+}
+function createWriter(file) {
+  const writerFor = (type, handleWrite) => (value) => {
+    const formatSymbol = compose(
+      (str) => str + (0, import_inflection3.capitalize)(type),
+      format_name_default
+    );
+    return Promise.all(
+      value.map((item) => {
+        if (handleWrite) {
+          return handleWrite(item);
+        }
+        const path6 = (0, import_path7.join)("app", (0, import_inflection3.pluralize)(type), item);
+        const symbol = formatSymbol(item);
+        return appendFile(file, createExportStatement(symbol, path6));
+      })
+    );
+  };
+  return {
+    controllers: writerFor("controller"),
+    serializers: writerFor("serializer"),
+    models: writerFor("model", async (item) => {
+      const path6 = (0, import_path7.join)("app", "models", item);
+      const name = format_name_default(item);
+      return appendFile(file, createExportStatement(name, path6));
+    }),
+    migrations: writerFor("migration", async (item) => {
+      const path6 = (0, import_path7.join)("db", "migrate", item);
+      const name = chain(item).pipe((str) => (0, import_path7.basename)(str, ".js")).pipe(underscore).pipe((str) => str.substr(17)).pipe((str) => (0, import_inflection3.camelize)(str, true)).value();
+      await appendFile(
+        file,
+        createExportStatement(`up as ${name}Up`, path6, false)
+      );
+      await appendFile(
+        file,
+        createExportStatement(`down as ${name}Down`, path6, false)
+      );
+    })
+  };
+}
+async function createManifest(dir, assets, { useStrict }) {
+  const dist = (0, import_path7.join)(dir, "dist");
+  const file = (0, import_path7.join)(dist, "index.js");
+  const writer = createWriter(file);
+  await tryCatch(() => mkdir(dist));
+  await writeFile(file, useStrict ? "'use strict';\n\n" : "");
+  await Promise.all(
+    Array.from(assets).map(([key, value]) => {
+      const write = Reflect.get(writer, key);
+      if (write) {
+        return write(value);
+      } else if (!write && typeof value === "string") {
+        return appendFile(file, createExportStatement(key, value));
+      }
+      return Promise.resolve();
+    })
+  );
+}
+
+// src/packages/compiler/utils/create-boot-script.ts
+var import_path8 = __toESM(require("path"));
+
+// src/packages/template/utils/insert-values.ts
+function insertValues(strings, ...values) {
+  if (values.length) {
+    return strings.reduce((result, part, idx) => {
+      const raw = values[idx];
+      let value = "";
+      if (raw && typeof raw.toString === "function") {
+        value = raw.toString();
+      }
+      return result + part + value;
+    }, "");
+  }
+  return strings.join("");
+}
+
+// src/packages/template/index.ts
+var bodyPattern = /^\n([\s\S]+)\s{2}$/gm;
+var trailingWhitespace = /\s+$/;
+function template(strings, ...values) {
+  const compiled = insertValues(strings, ...values);
+  let [body] = compiled.match(bodyPattern) || [];
+  let indentLevel = /^\s{0,4}(.+)$/g;
+  if (!body) {
+    body = compiled;
+    indentLevel = /^\s{0,2}(.+)$/g;
+  }
+  return body.split("\n").slice(1).map((line2) => {
+    let str = line2.replace(indentLevel, "$1");
+    if (trailingWhitespace.test(str)) {
+      str = str.replace(trailingWhitespace, "");
+    }
+    return str;
+  }).join("\n");
+}
+
+// src/packages/compiler/utils/create-boot-script.ts
+async function createBootScript(dir, {
+  useStrict
+}) {
+  let data = template`
+    const CWD = process.cwd();
+    const { env: { PORT } } = process;
+    const { Application, config, database } = require('./bundle');
+
+    module.exports = new Application(
+      Object.assign(config, {
+        database,
+        path: CWD,
+        port: PORT
+      })
+    ).catch(err => {
+      process.send({
+        error: err ? err.stack : void 0,
+        message: 'error'
+      });
+    });
+  `;
+  if (useStrict) {
+    data = `'use strict';
+
+${data}`;
+  }
+  await writeFile(import_path8.default.join(dir, "dist", "boot.js"), data);
+}
+
+// src/packages/compiler/index.ts
+async function compile(dir, env, opts = {}) {
+  const { useStrict = false } = opts;
+  const local = import_path9.default.join(__dirname, "index.mjs");
+  const entry = import_path9.default.join(dir, "dist", "index.js");
+  const assets = await Promise.all([
+    readdir(import_path9.default.join(dir, "app", "models")),
+    readdir(import_path9.default.join(dir, "db", "migrate")),
+    readdirRec(import_path9.default.join(dir, "app", "controllers")),
+    readdirRec(import_path9.default.join(dir, "app", "serializers"))
+  ]).then((types) => {
+    let [models, migrations, controllers, serializers] = types;
+    models = models.filter(isJSFile);
+    migrations = migrations.filter(isJSFile);
+    controllers = controllers.filter(isJSFile);
+    serializers = serializers.filter(isJSFile);
+    return /* @__PURE__ */ new Map([
+      ["Application", import_path9.default.join("app", "index.js")],
+      ["config", import_path9.default.join("config", "environments", `${env}.js`)],
+      ["controllers", controllers],
+      ["database", import_path9.default.join("config", "database.js")],
+      ["migrations", migrations],
+      ["models", models],
+      ["routes", import_path9.default.join("app", "routes.js")],
+      ["seed", import_path9.default.join("db", "seed.js")],
+      ["serializers", serializers]
+    ]);
+  });
+  await Promise.all([
+    createManifest(dir, assets, { useStrict }),
+    createBootScript(dir, { useStrict })
+  ]);
+  await esbuild.build({
+    entryPoints: [entry],
+    outfile: import_path9.default.join(dir, "dist", "bundle.js"),
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    target: "node20",
+    sourcemap: true,
+    // Reproduces `rollup-plugin-lumen`: preserves each class's `.name` (Lumen keys
+    // models/controllers/serializers off it) against esbuild's own renaming.
+    keepNames: true,
+    // Bare specifiers stay external (knex, inflection, the app's own deps);
+    // relative paths and the two aliases below are bundled in. This matches the
+    // old `is-external` split, with the framework itself pulled in via LUMEN_LOCAL.
+    packages: "external",
+    alias: {
+      // Apps import the framework as `import { Model } from 'LUMEN_LOCAL'`.
+      LUMEN_LOCAL: local,
+      // ...and their own tree as `app/...`.
+      app: import_path9.default.join(dir, "app")
+    }
+  });
+  await rmrf_default(entry);
+}
+
+// src/packages/cli/commands/build.ts
+async function build2(useStrict = false) {
+  const spinner = new import_ora.default({
+    text: "Building your application...",
+    spinner: "dots"
+  });
+  spinner.start();
+  await compile(CWD, NODE_ENV, {
+    useStrict
+  });
+  spinner.stop();
+}
+
+// src/packages/cli/commands/create.ts
+var import_os3 = require("os");
+var import_ora2 = __toESM(require("ora"));
+var import_chalk10 = require("chalk");
+
+// src/packages/cli/utils/driver-for.ts
+var drivers = /* @__PURE__ */ new Map([
+  ["postgres", "pg"],
+  ["sqlite", "sqlite3"],
+  ["mysql", "mysql2"]
+]);
+function driverFor(database = "sqlite") {
+  return drivers.get(database) || "sqlite3";
+}
+
+// src/packages/cli/templates/application.ts
+var import_inflection4 = require("inflection");
+var application_default = (name) => {
+  const normalized = chain(name).pipe(underscore).pipe(import_inflection4.classify).value();
+  return template`
+    import { Application } from 'lumen-framework';
+
+    class ${normalized} extends Application {
+
+    }
+
+    export default ${normalized};
+  `;
+};
+
+// src/packages/cli/templates/config.ts
+var config_default = (name, env) => {
+  const isTestENV = env === "test";
+  const isProdENV = env === "production";
+  return template`
+    export default {
+      logging: {
+        level: ${isProdENV ? "'INFO'" : "'DEBUG'"},
+        format: ${isProdENV ? "'json'" : "'text'"},
+        enabled: ${(!isTestENV).toString()},
+
+        filter: {
+          params: []
+        }
+      }
+    };
+  `;
+};
+
+// src/packages/cli/templates/routes.ts
+var routes_default = () => template`
+  export default function routes() {
+
+  }
+`;
+
+// src/packages/cli/utils/indent.ts
+function indent(amount = 1) {
+  return " ".repeat(amount);
+}
+
+// src/packages/cli/templates/database.ts
+var database_default = (name, driver) => {
+  const schemaName = underscore(name);
+  let driverName = driver;
+  let template2 = "export default {\n";
+  let username;
+  if (!driverName) {
+    driverName = "sqlite3";
+  }
+  if (driverName === "pg") {
+    username = "postgres";
+  } else if (driverName !== "pg" && driverName !== "sqlite3") {
+    username = "root";
+  }
+  ["development", "test", "production"].forEach((environment) => {
+    template2 += `${indent(2)}${environment}: {
+`;
+    if (driverName !== "sqlite3") {
+      template2 += `${indent(4)}pool: 5,
+`;
+    }
+    template2 += `${indent(4)}driver: '${driverName}',
+`;
+    if (username) {
+      template2 += `${indent(4)}username: '${username}',
+`;
+    }
+    switch (environment) {
+      case "development":
+        template2 += `${indent(4)}database: '${schemaName}_dev'
+`;
+        break;
+      case "test":
+        template2 += `${indent(4)}database: '${schemaName}_test'
+`;
+        break;
+      case "production":
+        template2 += `${indent(4)}database: '${schemaName}_prod'
+`;
+        break;
+      default:
+        template2 += `${indent(4)}database: '${schemaName}_${environment}'
+`;
+        break;
+    }
+    template2 += `${indent(2)}}`;
+    if (environment !== "production") {
+      template2 += ",\n\n";
+    }
+  });
+  template2 += "\n};\n";
+  return template2;
+};
+
+// src/packages/cli/templates/seed.ts
+var seed_default = () => template`
+  export default async function seed() {
+
+  }
+`;
+
+// package.json
+var version = "3.0.0";
+
+// src/packages/cli/templates/package-json.ts
+var LUMEN_VERSION = version;
+var DRIVER_DEPS = {
+  sqlite3: { name: "sqlite3", version: "^5.1.7" },
+  pg: { name: "pg", version: "^8.16.3" },
+  mysql2: { name: "mysql2", version: "^3.15.3" }
+};
+var package_json_default = (name, driver) => {
+  const dbDriver = DRIVER_DEPS[driver] || DRIVER_DEPS.sqlite3;
+  const pkg = {
+    name,
+    version: "0.0.1",
+    description: "",
+    scripts: {
+      start: "lumen serve",
+      test: "lumen test",
+      lint: "eslint ."
+    },
+    author: "",
+    license: "MIT",
+    dependencies: {
+      knex: "^3.3.0",
+      "lumen-framework": LUMEN_VERSION,
+      [dbDriver.name]: dbDriver.version
+    },
+    devDependencies: {
+      "@eslint/js": "^9.39.5",
+      eslint: "^9.39.5",
+      globals: "^17.7.0"
+    },
+    engines: {
+      node: ">= 20"
+    }
+  };
+  if (dbDriver.name === "sqlite3") {
+    pkg.pnpm = { onlyBuiltDependencies: ["sqlite3"] };
+  }
+  return `${JSON.stringify(pkg, null, 2)}
+`;
+};
+
+// src/packages/cli/templates/eslint-config.ts
+var eslint_config_default = () => `import js from '@eslint/js';
+import globals from 'globals';
+
+export default [
+  js.configs.recommended,
+  {
+    languageOptions: {
+      ecmaVersion: 2023,
+      sourceType: 'module',
+      globals: {
+        ...globals.node
+      }
+    }
+  }
+];
+`;
+
+// src/packages/cli/templates/readme.ts
+var readme_default = (name) => template`
+  # ${name}
+
+  ## Installation
+
+  *   \`git clone https://github.com/<this-repository>\`
+  *   \`cd ${name}\`
+  *   \`npm install\`
+
+  ## Running / Development
+
+  *   \`lumen serve\`
+
+  ## Testing
+
+  *   \`lumen test\`
+
+  ## Further Reading / Useful Links
+  *   [Lumen](https://github.com/nickschot/lux/)
+  *   [Chai](http://chaijs.com/) / [Mocha](http://mochajs.org/)
+`;
+
+// src/packages/cli/templates/license.ts
+var license_default = () => template`
+  The MIT License (MIT)
+
+  Copyright (c) 2016
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+`;
+
+// src/packages/cli/templates/gitignore.ts
+var gitignore_default = () => template`
+  # See http://help.github.com/ignore-files/ for more about ignoring files.
+
+  # dependencies
+  /node_modules
+
+  # build
+  /dist
+
+  # logs
+  /log
+  npm-debug.log
+
+  # database
+  *.sqlite
+  *.sqlite-journal
+  *.sqlite-wal
+  *.sqlite-shm
+
+  # misc
+  *.DS_Store
+`;
+
+// src/packages/cli/generator/index.ts
+var import_chalk9 = require("chalk");
+
+// src/packages/cli/utils/create-prompt.ts
+var import_readline = require("readline");
+var YES = /^y(es)?$/i;
+function createPrompt() {
+  const prompt = (0, import_readline.createInterface)({
+    input: process.stdin,
+    output: process.stdout
+  });
+  prompt.setPrompt("");
+  return {
+    question(text) {
+      return new Promise((resolve2) => {
+        prompt.question(text, (answer) => {
+          resolve2(YES.test(answer));
+        });
+      });
+    },
+    close() {
+      prompt.close();
+    }
+  };
+}
+
+// src/packages/cli/generator/utils/generate-type.ts
+var generate_type_exports = {};
+__export(generate_type_exports, {
+  controller: () => controller,
+  middleware: () => middleware,
+  migration: () => migration,
+  model: () => model,
+  modelMigration: () => modelMigration,
+  resource: () => resource,
+  serializer: () => serializer,
+  util: () => util
+});
+var import_path12 = require("path");
+var import_chalk8 = require("chalk");
+var import_inflection19 = require("inflection");
+
+// src/packages/cli/generator/constants.ts
+var import_chalk = require("chalk");
+var NAMESPACED_RESOURCE_MESSAGE = template`
+
+  🎉  It looks like the resource you generated is within a namespace!
+
+  Lumen will only update your 'routes.js' file if you generate a resource at the\
+  root namespace (i.e 'lumen generate resource users').
+
+  In order to access the resource you have created, remember to manually update\
+  your 'routes.js' file.
+
+    Example:
+
+    export default function routes() {
+      ${(0, import_chalk.dim)("// this resource will be accessible at /users")}
+      this.resource('users');
+
+      this.namespace('admin', function () {
+        ${(0, import_chalk.dim)("// this resource will be accessible at /admin/users")}
+        this.resource('users');
+      });
+    }
+
+`;
+
+// src/packages/database/errors/invalid-driver-error.ts
+var import_chalk5 = require("chalk");
+
+// src/packages/database/constants.ts
+var VALID_DRIVERS = [
+  "pg",
+  "sqlite3",
+  "mssql",
+  "mysql",
+  "mysql2",
+  "mariasql",
+  "strong-oracle",
+  "oracle"
+];
+
+// src/packages/logger/constants.ts
+var DEBUG = "DEBUG";
+var INFO = "INFO";
+var WARN = "WARN";
+var ERROR = "ERROR";
+var FORMATS = new set_default(["text", "json"]);
+FORMATS.freeze();
+var LEVELS = new map_default([
+  [DEBUG, 0],
+  [INFO, 1],
+  [WARN, 2],
+  [ERROR, 3]
+]);
+LEVELS.freeze();
+
+// src/packages/logger/writer/index.ts
+var import_tty = require("tty");
+var import_chalk2 = require("chalk");
+
+// src/utils/entries.ts
+function entries(source) {
+  return Object.entries(source);
+}
+
+// src/utils/omit.ts
+function omit(src, ...omitted) {
+  return entries(src).filter(([key]) => omitted.indexOf(key) < 0).reduce(
+    (result, [key, value]) => ({
+      ...result,
+      [key]: value
+    }),
+    {}
+  );
+}
+
+// src/packages/logger/writer/constants.ts
+var import_ansi_regex = __toESM(require("ansi-regex"));
+var ANSI = (0, import_ansi_regex.default)();
+var STDOUT = /^(DEBUG|INFO)$/;
+var STDERR = /^(WARN|ERROR)$/;
+
+// src/utils/stringify.ts
+function stringify(value, spaces) {
+  if (isObject(value) || Array.isArray(value)) {
+    return JSON.stringify(value, null, spaces);
+  }
+  return String(value);
+}
+
+// src/packages/logger/writer/utils/format-message.ts
+function formatMessage(data, format) {
+  if (data instanceof Error) {
+    return data.stack;
+  } else if (format === "json") {
+    return stringify(data).replace(ANSI, "");
+  }
+  return stringify(data, 2);
+}
+
+// src/packages/logger/writer/index.ts
+function isMessageObject(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function createWriter2(format) {
+  return function write(data) {
+    const { level, ...etc } = data;
+    let { message, timestamp } = etc;
+    let output;
+    if (format === "json") {
+      output = {};
+      if (isMessageObject(message) && message.message) {
+        output = {
+          timestamp,
+          level,
+          message: message.message,
+          ...omit(message, "message")
+        };
+      } else {
+        output = {
+          timestamp,
+          level,
+          message
+        };
+      }
+      output = formatMessage(output, "json");
+    } else {
+      let columns = 0;
+      if (process.stdout instanceof import_tty.WriteStream) {
+        columns = process.stdout.columns;
+      }
+      message = formatMessage(message, "text");
+      switch (level) {
+        case WARN:
+          timestamp = (0, import_chalk2.yellow)(`[${timestamp}]`);
+          break;
+        case ERROR:
+          timestamp = (0, import_chalk2.red)(`[${timestamp}]`);
+          break;
+        default:
+          timestamp = (0, import_chalk2.dim)(`[${timestamp}]`);
+          break;
+      }
+      output = `${timestamp} ${message}
+
+${(0, import_chalk2.dim)("-").repeat(columns)}
+`;
+    }
+    if (STDOUT.test(level)) {
+      process.stdout.write(`${output}
+`);
+    } else if (STDERR.test(level)) {
+      process.stderr.write(`${output}
+`);
+    }
+  };
+}
+
+// src/packages/logger/request-logger/utils/log-text.ts
+var import_chalk4 = __toESM(require("chalk"));
+
+// src/packages/logger/request-logger/templates.ts
+var import_chalk3 = require("chalk");
+
+// src/packages/logger/utils/line.ts
+function line(strings, ...values) {
+  return insertValues(strings, ...values).replace(/(\r\n|\n|\r|)/gm, "").replace(/\s+/g, " ").trim();
+}
+
+// src/packages/logger/request-logger/templates.ts
+function countDigits(num) {
+  const digits = Math.floor(Math.log10(num) + 1);
+  return digits > 0 && Number.isFinite(digits) ? digits : 1;
+}
+function pad(startTime, endTime, duration) {
+  const maxLength = countDigits(endTime - startTime);
+  return " ".repeat(maxLength - countDigits(duration)) + duration;
+}
+var debugTemplate = ({
+  path: path6,
+  stats,
+  route,
+  method,
+  params,
+  colorStr,
+  startTime,
+  endTime,
+  statusCode,
+  statusMessage,
+  remoteAddress
+}) => `${line`
+  Processed ${(0, import_chalk3.cyan)(`${method}`)} "${path6}" from ${remoteAddress}
+  with ${Reflect.apply(colorStr, null, [`${statusCode}`])}
+  ${Reflect.apply(colorStr, null, [`${statusMessage}`])} by ${route ? `${(0, import_chalk3.yellow)(route.controller.constructor.name)}#${(0, import_chalk3.blue)(route.action)}` : null}
+`}
+
+${(0, import_chalk3.magenta)("Params")}
+
+${JSON.stringify(params, null, 2)}
+
+${(0, import_chalk3.magenta)("Stats")}
+
+${stats.map((stat2) => {
+  const { type, duration, controller: controller2 } = stat2;
+  let { name } = stat2;
+  name = (0, import_chalk3.blue)(name);
+  if (type === "action") {
+    name = `${(0, import_chalk3.yellow)(controller2)}#${name}`;
+  }
+  return `${pad(startTime, endTime, duration)} ms ${name}`;
+}).join("\n")}
+${pad(
+  startTime,
+  endTime,
+  stats.reduce((total, { duration }) => total + duration, 0)
+)} ms Total
+${(endTime - startTime).toString()} ms Actual`;
+var infoTemplate = ({
+  path: path6,
+  route,
+  method,
+  params,
+  colorStr,
+  startTime,
+  endTime,
+  statusCode,
+  statusMessage,
+  remoteAddress
+}) => line`
+Processed ${(0, import_chalk3.cyan)(`${method}`)} "${path6}" ${(0, import_chalk3.magenta)("Params")} ${JSON.stringify(
+  params
+)} from ${remoteAddress} in ${(endTime - startTime).toString()} ms with ${Reflect.apply(
+  colorStr,
+  null,
+  [`${statusCode}`]
+)} ${Reflect.apply(colorStr, null, [`${statusMessage}`])} by ${route ? `${(0, import_chalk3.yellow)(route.controller.constructor.name)}#${(0, import_chalk3.blue)(route.action)}` : null}
+`;
+
+// src/packages/logger/request-logger/utils/filter-params.ts
+function filterParams(params, ...filtered) {
+  return entries(params).map(([key, value]) => [
+    key,
+    filtered.indexOf(key) >= 0 ? "[FILTERED]" : value
+  ]).reduce(
+    (result, [key, value]) => ({
+      ...result,
+      [key]: value && typeof value === "object" && !Array.isArray(value) ? filterParams(value, ...filtered) : value
+    }),
+    {}
+  );
+}
+
+// src/packages/logger/request-logger/utils/log-text.ts
+function logText(logger, {
+  startTime,
+  request: req,
+  response: res
+}) {
+  res.once("finish", () => {
+    const endTime = Date.now();
+    const {
+      route,
+      method,
+      url: { path: path6 },
+      connection: { remoteAddress }
+    } = req;
+    const { stats, statusCode, statusMessage } = res;
+    const params = filterParams(req.params, ...logger.filter.params);
+    const statusColor = statusCode >= 200 && statusCode < 400 ? "green" : "red";
+    let colorStr = Reflect.get(import_chalk4.default, statusColor);
+    if (typeof colorStr === "undefined") {
+      colorStr = (str) => str;
+    }
+    const templateData = {
+      path: path6,
+      stats,
+      route,
+      method,
+      params,
+      colorStr,
+      startTime,
+      endTime,
+      statusCode: statusCode.toString(),
+      statusMessage,
+      remoteAddress
+    };
+    if (logger.level === DEBUG) {
+      logger.debug(debugTemplate(templateData));
+    } else {
+      logger.info(infoTemplate(templateData));
+    }
+  });
+}
+
+// src/packages/logger/request-logger/utils/log-json.ts
+var MESSAGE = "Processed Request";
+function logJSON(logger, {
+  request: req,
+  response: res
+}) {
+  res.once("finish", () => {
+    const {
+      method,
+      headers,
+      httpVersion,
+      url: { path: path6 },
+      connection: { remoteAddress }
+    } = req;
+    const { statusCode: status } = res;
+    const userAgent = headers.get("user-agent");
+    const protocol = `HTTP/${httpVersion}`;
+    const params = filterParams(req.params, ...logger.filter.params);
+    logger.info({
+      message: MESSAGE,
+      method,
+      path: path6,
+      params,
+      status,
+      protocol,
+      userAgent,
+      remoteAddress
+    });
+  });
+}
+
+// src/packages/logger/request-logger/index.ts
+function createRequestLogger(logger) {
+  return function request(req, res, { startTime }) {
+    if (logger.format === "json") {
+      logJSON(logger, {
+        startTime,
+        request: req,
+        response: res
+      });
+    } else {
+      logText(logger, {
+        startTime,
+        request: req,
+        response: res
+      });
+    }
+  };
+}
+
+// src/packages/logger/utils/sql.ts
+var PATTERN = /(?:,?`|'|").+(?:`|'|"),?/;
+function sql(strings, ...values) {
+  return insertValues(strings, ...values).split(" ").map((part) => {
+    if (PATTERN.test(part)) {
+      return part;
+    }
+    return part.toUpperCase();
+  }).join(" ");
+}
+
+// src/packages/logger/index.ts
+var Logger = class {
+  constructor({ level, format, filter, enabled }) {
+    let write = K;
+    let request = K;
+    if (!LUMEN_CONSOLE && enabled) {
+      write = createWriter2(format);
+      request = createRequestLogger(this);
+    }
+    Object.defineProperties(this, {
+      level: {
+        value: level,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      format: {
+        value: format,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      filter: {
+        value: filter,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      enabled: {
+        value: Boolean(enabled),
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      request: {
+        value: request,
+        writable: false,
+        enumerable: false,
+        configurable: false
+      }
+    });
+    const levelNum = LEVELS.get(level) || 0;
+    LEVELS.forEach((val, key) => {
+      Reflect.defineProperty(this, key.toLowerCase(), {
+        writable: false,
+        enumerable: false,
+        configurable: false,
+        value: val >= levelNum ? (message) => {
+          write({
+            message,
+            level: key,
+            timestamp: this.getTimestamp()
+          });
+        } : K
+      });
+    });
+  }
+  /**
+   * @method getTimestamp
+   * @return {String} The current time as an ISO8601 string.
+   * @private
+   */
+  getTimestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+};
+var logger_default = Logger;
+
+// src/packages/database/errors/invalid-driver-error.ts
+var InvalidDriverError = class extends Error {
+  constructor(driver) {
+    super(line`
+      Invalid database driver ${(0, import_chalk5.yellow)(driver)} in ./config/database.js.
+      Please use one of the following database drivers:
+      ${VALID_DRIVERS.map((str) => (0, import_chalk5.green)(str)).join(", ")}.
+    `);
+  }
+};
+var invalid_driver_error_default = InvalidDriverError;
+
+// src/packages/database/errors/model-missing-error.ts
+var ModelMissingError = class extends Error {
+  constructor(name) {
+    super(`Could not resolve model by name '${name}'`);
+  }
+};
+var model_missing_error_default = ModelMissingError;
+
+// src/packages/database/errors/migrations-pending-error.ts
+var import_chalk6 = require("chalk");
+var MigrationsPendingError = class extends Error {
+  constructor(migrations = []) {
+    const pending = migrations.map((str) => (0, import_chalk6.yellow)(str.substr(0, str.length - 3))).join(", ");
+    super(line`
+      The following migrations are pending ${pending}.
+      Please run ${(0, import_chalk6.green)("lumen db:migrate")} before starting your application.
+    `);
+  }
+};
+var migrations_pending_error_default = MigrationsPendingError;
+
+// src/packages/server/utils/create-server-error.ts
+function createServerError(Target, statusCode) {
+  const ServerError = class extends Target {
+    constructor(...args) {
+      super(...args);
+      this.statusCode = statusCode;
+    }
+  };
+  Reflect.defineProperty(ServerError, "name", {
+    value: Target.name
+  });
+  return ServerError;
+}
+
+// src/packages/database/errors/unique-constraint-error.ts
+var UniqueConstraintError = class extends Error {
+};
+var unique_constraint_error_default = createServerError(UniqueConstraintError, 409);
+
+// src/packages/database/errors/config-missing-error.ts
+var ConfigMissingError = class extends Error {
+  constructor(environment) {
+    super(`Database config not found for environment ${environment}.`);
+  }
+};
+var config_missing_error_default = ConfigMissingError;
+
+// src/packages/database/initialize.ts
+var import_cluster = __toESM(require("cluster"));
+
+// src/packages/database/utils/connect.ts
+var import_path10 = require("path");
+function connect(path6, config) {
+  let { pool } = config;
+  const { host, socket, driver, database, username, password, port, ssl, url } = config;
+  if (VALID_DRIVERS.indexOf(driver) < 0) {
+    throw new invalid_driver_error_default(driver);
+  }
+  if (pool && typeof pool === "number") {
+    pool = {
+      min: pool > 1 ? 2 : 1,
+      max: pool
+    };
+  }
+  const knex = require((0, import_path10.join)(path6, "node_modules", "knex"));
+  const usingSQLite = driver === "sqlite3";
+  const connection = DATABASE_URL || url || {
+    host,
+    database,
+    password,
+    port,
+    ssl,
+    user: username,
+    socketPath: socket,
+    filename: usingSQLite ? (0, import_path10.join)(path6, "db", `${database || "default"}_${NODE_ENV}.sqlite`) : void 0
+  };
+  return knex({
+    pool,
+    connection,
+    debug: false,
+    client: driver,
+    useNullAsDefault: usingSQLite
+  });
+}
+
+// src/packages/database/utils/create-migrations.ts
+async function createMigrations(schema) {
+  const hasTable = await schema().hasTable("migrations");
+  if (!hasTable) {
+    await schema().createTable("migrations", (table) => {
+      table.string("version", 16).primary();
+    });
+  }
+  return true;
+}
+
+// src/packages/database/utils/pending-migrations.ts
+async function pendingMigrations(appPath, table) {
+  const migrations = await readdir(`${appPath}/db/migrate`);
+  const versions = await table().select().then(
+    (data) => data.map(({ version: version2 }) => version2)
+  );
+  return migrations.filter(
+    (migration2) => versions.indexOf(migration2.replace(/^(\d{16})-.+$/g, "$1")) < 0
+  );
+}
+
+// src/packages/database/initialize.ts
+async function initialize2(instance, opts) {
+  const { path: path6, models, logger, checkMigrations } = opts;
+  const config = Reflect.get(opts.config, NODE_ENV);
+  if (!config) {
+    throw new config_missing_error_default(NODE_ENV);
+  }
+  const { debug = NODE_ENV === "development" } = config;
+  Object.defineProperties(instance, {
+    path: {
+      value: path6,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    },
+    debug: {
+      value: debug,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    },
+    models: {
+      value: models,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    },
+    logger: {
+      value: logger,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    },
+    config: {
+      value: config,
+      writable: false,
+      enumerable: true,
+      configurable: false
+    },
+    schema: {
+      value: () => instance.connection.schema,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    },
+    connection: {
+      value: connect(path6, config),
+      writable: false,
+      enumerable: false,
+      configurable: false
+    }
+  });
+  if (import_cluster.default.isMaster || import_cluster.default.worker && import_cluster.default.worker.id === 1) {
+    await createMigrations(instance.schema);
+    if (checkMigrations) {
+      const pending = await pendingMigrations(
+        path6,
+        () => instance.connection("migrations")
+      );
+      if (pending.length) {
+        throw new migrations_pending_error_default(pending);
+      }
+    }
+  }
+  await Promise.all(
+    Array.from(models.values()).map(
+      (model2) => model2.initialize(instance, () => instance.connection(model2.tableName))
+    )
+  );
+  return instance;
+}
+
+// src/packages/database/utils/normalize-model-name.ts
+var import_inflection5 = require("inflection");
+var normalize_model_name_default = compose(import_inflection5.singularize, import_inflection5.dasherize, underscore);
+
+// src/packages/database/model/index.ts
+var import_inflection12 = require("inflection");
+
+// src/packages/database/query/index.ts
+var import_inflection8 = require("inflection");
+
+// src/packages/database/query/utils/format-select.ts
+var import_inflection6 = require("inflection");
+
+// src/packages/database/query/errors/record-not-found-error.ts
+var RecordNotFoundError = class extends Error {
+  constructor({ name, primaryKey }, primaryKeyValue) {
+    super(
+      `Could not find ${name} with ${primaryKey} ${stringify(primaryKeyValue)}.`
+    );
+  }
+};
+var record_not_found_error_default = createServerError(RecordNotFoundError, 404);
+
+// src/packages/database/query/runner/utils/build-results.ts
+var import_inflection7 = require("inflection");
+
+// src/packages/database/relationship/index.ts
+var import_inflection10 = require("inflection");
+
+// src/packages/database/relationship/utils/getters.ts
+var import_inflection9 = require("inflection");
+
+// src/packages/database/model/initialize-class.ts
+var import_inflection11 = require("inflection");
+
+// src/packages/database/migration/utils/generate-timestamp.ts
+function formatInt(int) {
+  return (int / 10).toString().replace(".", "").substr(0, 2);
+}
+function* padding(char, amount) {
+  for (let i = 0; i < amount; i += 1) {
+    yield char;
+  }
+}
+function generateTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString().substr(0, 10).split("-").join("") + formatInt(now.getHours()) + formatInt(now.getMinutes()) + formatInt(now.getSeconds()) + formatInt(now.getMilliseconds());
+  return timestamp + Array.from(padding("0", 16 - timestamp.length)).join("");
+}
+
+// src/packages/database/migration/index.ts
+var Migration = class {
+  constructor(fn) {
+    this.fn = fn;
+  }
+  run(schema) {
+    return this.fn(schema);
+  }
+};
+var migration_default = Migration;
+
+// src/packages/database/index.ts
+var Database = class {
+  constructor(opts) {
+    return initialize2(this, opts);
+  }
+  modelFor(type) {
+    const model2 = this.models.get(normalize_model_name_default(type));
+    if (!model2) {
+      throw new model_missing_error_default(type);
+    }
+    return model2;
+  }
+};
+var database_default2 = Database;
+
+// src/packages/cli/templates/model.ts
+var import_os2 = require("os");
+var import_inflection13 = require("inflection");
+var VALID_ATTR = /^(\w|-)+:(\w|-)+$/;
+var RELATIONSHIP = /^belongs-to|has-(one|many)$/;
+var model_default2 = (name, attrs) => {
+  const normalized = chain(name).pipe(underscore).pipe(import_inflection13.classify).value();
+  return template`
+    import { Model } from 'lumen-framework';
+
+    class ${normalized} extends Model {
+    ${entries(
+    (attrs || []).filter((attr) => VALID_ATTR.test(attr)).map((attr) => attr.split(":")).filter(([, type]) => RELATIONSHIP.test(type)).reduce(
+      (types, [related, type]) => {
+        const key = chain(type).pipe(underscore).pipe((str) => (0, import_inflection13.camelize)(str, true)).value();
+        const value = Reflect.get(types, key);
+        if (value) {
+          const inverse = (0, import_inflection13.camelize)(normalized, true);
+          const relatedKey = chain(related).pipe(underscore).pipe((str) => (0, import_inflection13.camelize)(str, true)).value();
+          return {
+            ...types,
+            [key]: [
+              ...value,
+              `${indent(8)}${relatedKey}: {${import_os2.EOL}${indent(10)}inverse: '${inverse}'${import_os2.EOL}${indent(8)}}`
+            ]
+          };
+        }
+        return types;
+      },
+      {
+        hasOne: [],
+        hasMany: [],
+        belongsTo: []
+      }
+    )
+  ).filter(([, value]) => value.length).reduce(
+    (result, [key, value], index) => chain(result).pipe((str) => {
+      if (index && str.length) {
+        return `${str}${import_os2.EOL.repeat(2)}`;
+      }
+      return str;
+    }).pipe(
+      (str) => str + `${indent(index === 0 ? 2 : 6)}static ${key} = {${import_os2.EOL}${value.join(`,${import_os2.EOL.repeat(2)}`)}${import_os2.EOL}${indent(6)}};`
+    ).value(),
+    ""
+  )}
+    }
+
+    export default ${normalized};
+  `;
+};
+
+// src/packages/cli/templates/serializer.ts
+var import_inflection14 = require("inflection");
+var serializer_default = (name, attrs) => {
+  let normalized = chain(name).pipe(underscore).pipe(import_inflection14.classify).value();
+  if (!normalized.endsWith("Application")) {
+    normalized = (0, import_inflection14.pluralize)(normalized);
+  }
+  const body = entries(
+    attrs.filter((attr) => /^(\w|-)+:(\w|-)+$/g.test(attr)).map((attr) => attr.split(":")).reduce(
+      (obj, parts) => {
+        const [, type] = parts;
+        let [attr] = parts;
+        let { hasOne, hasMany, attributes } = obj;
+        attr = `${indent(8)}'${(0, import_inflection14.camelize)(underscore(attr), true)}'`;
+        switch (type) {
+          case "belongs-to":
+          case "has-one":
+            hasOne = [...hasOne, attr];
+            break;
+          case "has-many":
+            hasMany = [...hasMany, attr];
+            break;
+          default:
+            attributes = [...attributes, attr];
+        }
+        return {
+          attributes,
+          hasOne,
+          hasMany
+        };
+      },
+      {
+        // `belongsTo` was a dead accumulator key — never destructured and, for
+        // non-empty attrs, never present in the returned object — so it emitted
+        // nothing. Dropped so the accumulator types cleanly.
+        attributes: [],
+        hasOne: [],
+        hasMany: []
+      }
+    )
+  ).reduce((result, group, index) => {
+    const [key, items] = group;
+    let str = result;
+    if (items.length) {
+      const value = items.join(",\n");
+      if (index && str.length) {
+        str += "\n\n";
+      }
+      str += `${indent(index === 0 ? 2 : 6)}${key} = [
+${value}
+${indent(6)}];`;
+    }
+    return str;
+  }, "");
+  return template`
+    import { Serializer } from 'lumen-framework';
+
+    class ${normalized}Serializer extends Serializer {
+    ${body}
+    }
+
+    export default ${normalized}Serializer;
+  `;
+};
+
+// src/packages/cli/templates/controller.ts
+var import_inflection15 = require("inflection");
+var controller_default = (name, attrs) => {
+  let normalized = chain(name).pipe(underscore).pipe(import_inflection15.classify).value();
+  if (!normalized.endsWith("Application")) {
+    normalized = (0, import_inflection15.pluralize)(normalized);
+  }
+  const body = entries(
+    attrs.filter((attr) => /^(\w|-)+:(\w|-)+$/g.test(attr)).map((attr) => attr.split(":")[0]).reduce(
+      (obj, attr) => ({
+        ...obj,
+        params: [
+          ...obj.params,
+          `${indent(8)}'${(0, import_inflection15.camelize)(underscore(attr), true)}'`
+        ]
+      }),
+      { params: [] }
+    )
+  ).reduce((result, group, index) => {
+    const [key, items] = group;
+    let str = result;
+    if (items.length) {
+      const value = items.join(",\n");
+      if (index && str.length) {
+        str += "\n\n";
+      }
+      str += `${indent(index === 0 ? 2 : 6)}${key} = [
+${value}
+${indent(6)}];`;
+    }
+    return str;
+  }, "");
+  return template`
+    import { Controller } from 'lumen-framework';
+
+    class ${normalized}Controller extends Controller {
+    ${body}
+    }
+
+    export default ${normalized}Controller;
+  `;
+};
+
+// src/packages/cli/templates/empty-migration.ts
+var empty_migration_default = () => template`
+  export function up(schema) {
+
+  }
+
+  export function down(schema) {
+
+  }
+`;
+
+// src/packages/cli/templates/model-migration.ts
+var import_inflection16 = require("inflection");
+var model_migration_default = (name, attrs) => {
+  const indices = ["id"];
+  const table = chain(name).pipe((str) => str.substr(24)).pipe(underscore).pipe(import_inflection16.pluralize).value();
+  let body = "";
+  if (Array.isArray(attrs)) {
+    body = attrs.filter((attr) => /^(\w|-)+:(\w|-)+$/g.test(attr)).map((attr) => attr.split(":")).filter(([, type]) => !/^has-(one|many)$/g.test(type)).map((attr) => {
+      let [column, type] = attr;
+      column = underscore(column);
+      if (type === "belongs-to") {
+        type = "integer";
+        column = `${column}_id`;
+        if (Array.isArray(indices)) {
+          indices.push(column);
+        }
+      }
+      return [column, type];
+    }).map((attr, index) => {
+      let [column] = attr;
+      const [, type] = attr;
+      const shouldIndex = indices.indexOf(column) >= 0;
+      column = `${indent(index > 0 ? 8 : 0)}table.${type}('${column}')`;
+      return shouldIndex ? `${column}.index();` : `${column};`;
+    }).join("\n");
+  }
+  return template`
+    export function up(schema) {
+      return schema.createTable('${table}', table => {
+        table.increments('id');
+        ${body}
+        table.timestamps();
+
+        table.index('created_at');
+        table.index('updated_at');
+      });
+    }
+
+    export function down(schema) {
+      return schema.dropTable('${table}');
+    }
+  `;
+};
+
+// src/packages/cli/templates/middleware.ts
+var import_inflection17 = require("inflection");
+var middleware_default = (name) => {
+  const normalized = chain(name).pipe(underscore).pipe((str) => (0, import_inflection17.camelize)(str, true)).value();
+  return template`
+    export default function ${normalized}(/*request, response*/) {
+
+    }
+  `;
+};
+
+// src/packages/cli/templates/util.ts
+var import_inflection18 = require("inflection");
+var util_default = (name) => {
+  const normalized = chain(name).pipe(underscore).pipe((str) => (0, import_inflection18.camelize)(str, true)).value();
+  return template`
+    export default function ${normalized}() {
+
+    }
+  `;
+};
+
+// src/packages/cli/generator/utils/log.ts
+function log(data) {
+  if (data instanceof Error) {
+    process.stdout.write(`${data.stack || data.message}
+`);
+  } else {
+    process.stderr.write(`${data}
+`);
+  }
+}
+
+// src/packages/cli/generator/utils/create-generator.ts
+var import_path11 = require("path");
+var import_chalk7 = require("chalk");
+var FORWARD_SLASH = /\//g;
+function createGenerator({
+  dir,
+  template: template2,
+  hasConflict = exists
+}) {
+  return async ({ cwd, attrs, onConflict, ...opts }) => {
+    const path6 = resolvePath(cwd, dir, `${opts.name}.js`);
+    const name = opts.name.replace(FORWARD_SLASH, "-");
+    let action = (0, import_chalk7.green)("create");
+    await mkdirRec(path6.dir);
+    if (await hasConflict(path6.absolute)) {
+      const shouldContinue = await onConflict(path6.relative);
+      if (shouldContinue && typeof shouldContinue === "string") {
+        await rmrf_default((0, import_path11.join)(path6.dir, shouldContinue));
+        log(`${(0, import_chalk7.red)("remove")} ${(0, import_path11.join)(dir, shouldContinue)}`);
+      } else if (shouldContinue && typeof shouldContinue === "boolean") {
+        action = (0, import_chalk7.yellow)("overwrite");
+        await rmrf_default(path6.absolute);
+      } else {
+        log(`${(0, import_chalk7.yellow)("skip")} ${path6.relative}`);
+        return;
+      }
+    }
+    await writeFile(path6.absolute, template2(name, attrs));
+    log(`${action} ${path6.relative}`);
+  };
+}
+
+// src/packages/cli/generator/utils/migration-conflict.ts
+function detectConflict(path6) {
+  const { dir, base } = resolvePath(path6);
+  const pattern = new RegExp(`^\\d+-${base.substr(17)}$`);
+  return exists(pattern, dir);
+}
+function createConflictResolver({
+  cwd,
+  onConflict
+}) {
+  return async (path6) => {
+    if (await onConflict(path6)) {
+      const parsed = resolvePath(cwd, path6);
+      const migrations = await readdir(parsed.dir);
+      return migrations.find((file) => file.substr(17) === parsed.base.substr(17)) || false;
+    }
+    return false;
+  };
+}
+
+// src/packages/cli/generator/utils/generate-type.ts
+async function controller(opts) {
+  const { cwd } = opts;
+  let { name } = opts;
+  const dir = (0, import_path12.join)("app", "controllers");
+  const generate2 = createGenerator({
+    dir,
+    template: controller_default
+  });
+  if (!name.endsWith("application")) {
+    name = (0, import_inflection19.pluralize)(name);
+  }
+  await generate2({
+    ...opts,
+    cwd,
+    name
+  });
+  const namespace = import_path12.posix.dirname(name);
+  if (namespace !== ".") {
+    const hasParent = await exists(
+      (0, import_path12.join)(cwd, dir, ...[...namespace.split("/"), "application.js"])
+    );
+    if (!hasParent) {
+      await controller({
+        ...opts,
+        cwd,
+        name: `${namespace}/application`,
+        attrs: []
+      });
+    }
+  }
+}
+async function serializer(opts) {
+  const { cwd } = opts;
+  let { name } = opts;
+  const dir = (0, import_path12.join)("app", "serializers");
+  const generate2 = createGenerator({
+    dir,
+    template: serializer_default
+  });
+  if (!name.endsWith("application")) {
+    name = (0, import_inflection19.pluralize)(name);
+  }
+  await generate2({
+    ...opts,
+    cwd,
+    name
+  });
+  const namespace = import_path12.posix.dirname(name);
+  if (namespace !== ".") {
+    const hasParent = await exists(
+      (0, import_path12.join)(cwd, dir, ...[...namespace.split("/"), "application.js"])
+    );
+    if (!hasParent) {
+      await serializer({
+        ...opts,
+        cwd,
+        name: `${namespace}/application`,
+        attrs: []
+      });
+    }
+  }
+}
+function migration(opts) {
+  const { cwd, onConflict } = opts;
+  let { name } = opts;
+  const dir = (0, import_path12.join)("db", "migrate");
+  const generate2 = createGenerator({
+    dir,
+    template: empty_migration_default,
+    hasConflict: detectConflict
+  });
+  name = chain(name).pipe(import_path12.posix.basename).pipe((str) => `${generateTimestamp()}-${str}`).value();
+  return generate2({
+    ...opts,
+    cwd,
+    name,
+    onConflict: createConflictResolver({
+      cwd,
+      onConflict
+    })
+  });
+}
+function modelMigration(opts) {
+  const { cwd, onConflict } = opts;
+  let { name } = opts;
+  const dir = (0, import_path12.join)("db", "migrate");
+  const generate2 = createGenerator({
+    dir,
+    template: model_migration_default,
+    hasConflict: detectConflict
+  });
+  name = chain(name).pipe(import_path12.posix.basename).pipe(import_inflection19.pluralize).pipe((str) => `${generateTimestamp()}-create-${str}`).value();
+  return generate2({
+    ...opts,
+    cwd,
+    name,
+    onConflict: createConflictResolver({
+      cwd,
+      onConflict
+    })
+  });
+}
+async function model(opts) {
+  let { name } = opts;
+  const generate2 = createGenerator({
+    dir: (0, import_path12.join)("app", "models"),
+    template: model_default2
+  });
+  await modelMigration({ ...opts, name });
+  name = chain(name).pipe(import_path12.posix.basename).pipe(import_inflection19.singularize).value();
+  return generate2({
+    ...opts,
+    name
+  });
+}
+function middleware(opts) {
+  let { name } = opts;
+  const parts = name.split("/");
+  name = parts.pop() || name;
+  const generate2 = createGenerator({
+    dir: (0, import_path12.join)("app", "middleware", ...parts),
+    template: middleware_default
+  });
+  return generate2({
+    ...opts,
+    name
+  });
+}
+function util(opts) {
+  let { name } = opts;
+  const parts = name.split("/");
+  name = parts.pop() || name;
+  const generate2 = createGenerator({
+    dir: (0, import_path12.join)("app", "utils", ...parts),
+    template: util_default
+  });
+  return generate2({
+    ...opts,
+    name
+  });
+}
+async function resource(opts) {
+  await model(opts);
+  await controller(opts);
+  await serializer(opts);
+  if (import_path12.posix.dirname(opts.name) !== ".") {
+    log(NAMESPACED_RESOURCE_MESSAGE);
+    return;
+  }
+  const path6 = (0, import_path12.join)(opts.cwd, "app", "routes.js");
+  const routes = chain(await readFile(path6)).pipe((buf) => buf.toString("utf8")).pipe((str) => str.split("\n")).pipe(
+    (lines) => lines.reduce((result, line2, index, arr) => {
+      const closeIndex = arr.lastIndexOf("}");
+      let str = result;
+      if (line2 && index <= closeIndex) {
+        str += `${line2}
+`;
+      }
+      if (index + 1 === closeIndex) {
+        str += `  this.resource('${(0, import_inflection19.pluralize)(opts.name)}');
+`;
+      }
+      return str;
+    }, "")
+  ).value();
+  await writeFile(path6, routes);
+  log(`${(0, import_chalk8.green)("update")} app/routes.js`);
+}
+
+// src/packages/cli/generator/utils/generator-for.ts
+function generatorFor(type) {
+  const normalized = type.toLowerCase();
+  const generator = Reflect.get(generate_type_exports, normalized);
+  if (!generator) {
+    throw new Error(`Could not find a generator for '${type}'.`);
+  }
+  return generator;
+}
+
+// src/packages/cli/generator/index.ts
+async function runGenerator({
+  cwd,
+  type,
+  name,
+  attrs
+}) {
+  const generator = generatorFor(type);
+  const prompt = createPrompt();
+  await generator({
+    cwd,
+    type,
+    name,
+    attrs,
+    onConflict: (path6) => prompt.question(`${(0, import_chalk9.green)("?")} ${(0, import_chalk9.red)("Overwrite")} ${path6}? (Y/n)\r`)
+  });
+  prompt.close();
+}
+
+// src/packages/cli/commands/generate.ts
+function generate({
+  cwd = CWD,
+  name,
+  type,
+  attrs = []
+}) {
+  return runGenerator({
+    cwd,
+    name,
+    type,
+    attrs
+  });
+}
+
+// src/packages/cli/commands/create.ts
+async function create2(name, database) {
+  const driver = driverFor(database);
+  const project = `${CWD}/${name}`;
+  await mkdir(project);
+  await Promise.all([
+    mkdir(`${project}/app`),
+    mkdir(`${project}/config`),
+    mkdir(`${project}/db`)
+  ]);
+  await Promise.all([
+    mkdir(`${project}/app/models`),
+    mkdir(`${project}/app/serializers`),
+    mkdir(`${project}/app/controllers`),
+    mkdir(`${project}/app/middleware`),
+    mkdir(`${project}/app/utils`),
+    mkdir(`${project}/config/environments`),
+    mkdir(`${project}/db/migrate`)
+  ]);
+  await Promise.all([
+    writeFile(`${project}/app/index.js`, application_default(name)),
+    writeFile(`${project}/app/routes.js`, routes_default()),
+    writeFile(
+      `${project}/config/environments/development.js`,
+      config_default(name, "development")
+    ),
+    writeFile(
+      `${project}/config/environments/test.js`,
+      config_default(name, "test")
+    ),
+    writeFile(
+      `${project}/config/environments/production.js`,
+      config_default(name, "production")
+    ),
+    writeFile(`${project}/config/database.js`, database_default(name, driver)),
+    writeFile(`${project}/db/seed.js`, seed_default()),
+    writeFile(`${project}/README.md`, readme_default(name)),
+    writeFile(`${project}/LICENSE`, license_default()),
+    writeFile(`${project}/package.json`, package_json_default(name, driver)),
+    writeFile(`${project}/eslint.config.mjs`, eslint_config_default()),
+    writeFile(`${project}/.gitignore`, gitignore_default())
+  ]);
+  const logOutput = template`
+    ${(0, import_chalk10.green)("create")} app/index.js
+    ${(0, import_chalk10.green)("create")} app/routes.js
+    ${(0, import_chalk10.green)("create")} bin/app.js
+    ${(0, import_chalk10.green)("create")} config/environments/development.js
+    ${(0, import_chalk10.green)("create")} config/environments/test.js
+    ${(0, import_chalk10.green)("create")} config/environments/production.js
+    ${(0, import_chalk10.green)("create")} config/database.js
+    ${(0, import_chalk10.green)("create")} db/migrate
+    ${(0, import_chalk10.green)("create")} db/seed.js
+    ${(0, import_chalk10.green)("create")} README.md
+    ${(0, import_chalk10.green)("create")} LICENSE
+    ${(0, import_chalk10.green)("create")} package.json
+    ${(0, import_chalk10.green)("create")} eslint.config.mjs
+    ${(0, import_chalk10.green)("create")} .gitignore
+  `;
+  process.stdout.write(logOutput.substr(0, logOutput.length - 1));
+  process.stdout.write(import_os3.EOL);
+  await Promise.all([
+    generate({
+      cwd: project,
+      type: "serializer",
+      name: "application"
+    }),
+    generate({
+      cwd: project,
+      type: "controller",
+      name: "application"
+    })
+  ]);
+  await exec("git init && git add .", {
+    cwd: project
+  });
+  process.stdout.write(`${(0, import_chalk10.green)("initialize")} git`);
+  process.stdout.write(import_os3.EOL);
+  const spinner = new import_ora2.default({
+    text: "Installing dependencies from npm...",
+    spinner: "dots"
+  });
+  spinner.start();
+  await exec("npm install", {
+    cwd: project
+  });
+  spinner.stop();
+}
+
+// src/packages/cli/commands/dbcreate.ts
+var import_os4 = require("os");
+
+// src/utils/github.ts
+var GITHUB_URL = "https://github.com/nickschot/lux";
+function fileLink(path6, opts = {}) {
+  const { line: line2, branch = "master" } = opts;
+  let link = `${GITHUB_URL}/blob/${branch}/${path6}`;
+  if (line2 && line2 >= 0) {
+    link += `#${line2}`;
+  }
+  return link;
+}
+
+// src/packages/cli/constants.ts
+var DB_INTERFACE_URL = fileLink("src/packages/database/interfaces.js", {
+  line: 17
+});
+var CONNECTION_STRING_MESSAGE = template`
+
+    You're using a URL in your database config (config/database.js).
+
+    In that case, Lumen assumes you don't need to create or drop your database.
+    If you'd like to create or drop a database, set up your database config
+    without the url.
+
+    For guidance, see:
+    ${DB_INTERFACE_URL}
+`;
+
+// src/packages/cli/errors/database-config-missing.ts
+var DatabaseConfigMissingError = class extends ReferenceError {
+  constructor(environment) {
+    super(`Could not find database config for environment "${environment}".`);
+  }
+};
+var database_config_missing_default = DatabaseConfigMissingError;
+
+// src/packages/loader/utils/bundle-for.ts
+var import_path13 = require("path");
+
+// src/packages/config/index.ts
+function createDefaultConfig() {
+  const isTestENV = NODE_ENV === "test";
+  const isProdENV = NODE_ENV === "production";
+  return {
+    server: {
+      cors: {
+        enabled: false
+      }
+    },
+    logging: {
+      level: isProdENV ? "INFO" : "DEBUG",
+      format: isProdENV ? "json" : "text",
+      enabled: !isTestENV,
+      filter: {
+        params: []
+      }
+    }
+  };
+}
+
+// src/utils/merge.ts
+function hasOwnProperty2(target, key) {
+  return Reflect.apply(Object.prototype.hasOwnProperty, target, [key]);
+}
+function merge(dest, source) {
+  return entries(source).reduce(
+    (result, [key, value]) => {
+      if (hasOwnProperty2(result, key) && isObject(value)) {
+        const currentValue = Reflect.get(result, key);
+        if (isObject(currentValue)) {
+          return {
+            ...result,
+            [key]: merge(currentValue, value)
+          };
+        }
+      }
+      return {
+        ...result,
+        [key]: value
+      };
+    },
+    { ...dest }
+  );
+}
+
+// src/packages/loader/utils/format-key.ts
+var import_inflection20 = require("inflection");
+var NAMESPACE_DELIMITER = /\$-/g;
+function formatKey(key, formatter) {
+  return chain(key).pipe((str) => {
+    if (formatter) {
+      return formatter(str);
+    }
+    return str;
+  }).pipe(underscore).pipe(import_inflection20.dasherize).pipe((str) => str.replace(NAMESPACE_DELIMITER, "/")).value();
+}
+
+// src/packages/loader/utils/bundle-for.ts
+var SUFFIX_PATTERN = /^.+(Controller|Down|Serializer|Up)/;
+function normalize(manifest) {
+  return entries(manifest).reduce(
+    (obj, [key, value]) => {
+      if (SUFFIX_PATTERN.test(key)) {
+        const suffix = key.replace(SUFFIX_PATTERN, "$1");
+        const stripSuffix = (source) => source.replace(suffix, "");
+        switch (suffix) {
+          case "Controller":
+            obj.controllers.set(formatKey(key, stripSuffix), value);
+            break;
+          case "Serializer":
+            obj.serializers.set(formatKey(key, stripSuffix), value);
+            break;
+          case "Up":
+          case "Down":
+            obj.migrations.set(
+              formatKey(key),
+              Reflect.construct(migration_default, [value])
+            );
+            break;
+          default:
+            break;
+        }
+      } else {
+        switch (key) {
+          case "Application":
+          case "routes":
+          case "seed":
+            Reflect.set(obj, formatKey(key), value);
+            break;
+          case "config":
+            Reflect.set(obj, "config", {
+              ...merge(createDefaultConfig(), {
+                ...obj.config,
+                ...value
+              })
+            });
+            break;
+          case "database":
+            Reflect.set(obj, "config", {
+              ...obj.config,
+              database: value
+            });
+            break;
+          default:
+            obj.models.set(formatKey(key), value);
+            break;
+        }
+      }
+      return obj;
+    },
+    {
+      config: {},
+      controllers: new map_default(),
+      migrations: new map_default(),
+      models: new map_default(),
+      serializers: new map_default()
+    }
+  );
+}
+function bundleFor(path6) {
+  const manifest = Reflect.apply(require, null, [
+    (0, import_path13.join)(path6, "dist", "bundle")
+  ]);
+  return chain(manifest).pipe(normalize).pipe(entries).pipe((pairs) => new map_default(pairs)).value().freeze();
+}
+
+// src/packages/loader/index.ts
+function createLoader(path6) {
+  let bundle;
+  return function load(type) {
+    if (!bundle) {
+      bundle = bundleFor(path6);
+    }
+    return bundle.get(type);
+  };
+}
+
+// src/packages/cli/commands/dbcreate.ts
+function dbcreate() {
+  const load = createLoader(CWD);
+  const config = Reflect.get(load("config").database, NODE_ENV);
+  if (!config) {
+    throw new database_config_missing_default(NODE_ENV);
+  }
+  if (config.driver === "sqlite3") {
+    return writeFile(`${CWD}/db/${config.database}_${NODE_ENV}.sqlite`, "");
+  }
+  if (DATABASE_URL || config.url) {
+    process.stderr.write(CONNECTION_STRING_MESSAGE);
+    process.stderr.write(import_os4.EOL);
+    return Promise.resolve();
+  }
+  const { schema } = connect(CWD, config);
+  const query = `CREATE DATABASE ${config.database}`;
+  const raw = schema.raw(query);
+  return raw.once("query", () => {
+    process.stdout.write(query);
+    process.stdout.write(import_os4.EOL);
+  });
+}
+
+// src/packages/cli/commands/dbdrop.ts
+var import_os5 = require("os");
+function dbdrop() {
+  const load = createLoader(CWD);
+  const config = Reflect.get(load("config").database, NODE_ENV);
+  if (!config) {
+    throw new database_config_missing_default(NODE_ENV);
+  }
+  if (config.driver === "sqlite3") {
+    return rmrf_default(`${CWD}/db/${config.database}_${NODE_ENV}.sqlite`);
+  }
+  if (DATABASE_URL || config.url) {
+    process.stderr.write(CONNECTION_STRING_MESSAGE);
+    process.stderr.write(import_os5.EOL);
+    return Promise.resolve();
+  }
+  const { schema } = connect(CWD, config);
+  const query = `DROP DATABASE IF EXISTS ${config.database}`;
+  const raw = schema.raw(query);
+  return raw.once("query", () => {
+    process.stdout.write(query);
+    process.stdout.write(import_os5.EOL);
+  });
+}
+
+// src/packages/cli/commands/dbmigrate.ts
+var import_os6 = require("os");
+async function dbmigrate() {
+  const load = createLoader(CWD);
+  const { database: config } = load("config");
+  const models = load("models");
+  const migrations = load("migrations");
+  const { connection, schema } = await new database_default2({
+    config,
+    models,
+    path: CWD,
+    checkMigrations: false,
+    logger: new logger_default({ enabled: false })
+  });
+  const pending = await pendingMigrations(CWD, () => connection("migrations"));
+  if (pending.length) {
+    const runners = pending.map((name) => {
+      const version2 = name.replace(/^(\d{16})-.+$/g, "$1");
+      const key = name.replace(new RegExp(`${version2}-(.+)\\.js`), "$1");
+      return [version2, migrations.get(`${key}-up`)];
+    }).filter(([, migration2]) => Boolean(migration2)).reverse().map(([version2, migration2]) => () => {
+      const query = migration2.run(schema());
+      return query.on("query", () => {
+        process.stdout.write(sql`${query.toString()}`);
+        process.stdout.write(import_os6.EOL);
+      }).then(
+        () => connection("migrations").insert({
+          version: version2
+        })
+      );
+    });
+    await composeAsync(...runners)();
+  }
+  return true;
+}
+
+// src/packages/cli/commands/dbrollback.ts
+var import_os7 = require("os");
+async function dbrollback() {
+  const load = createLoader(CWD);
+  const { database: config } = load("config");
+  const models = load("models");
+  const migrations = load("migrations");
+  const { connection, schema } = await new database_default2({
+    config,
+    models,
+    path: CWD,
+    checkMigrations: false,
+    logger: new logger_default({ enabled: false })
+  });
+  const migrationFiles = await readdir(`${CWD}/db/migrate`);
+  if (migrationFiles.length) {
+    let migration2;
+    let version2 = await connection("migrations").orderBy("version", "desc").first();
+    if (version2 && version2.version) {
+      version2 = version2.version;
+    }
+    const target = migrationFiles.find((m) => m.indexOf(version2) === 0);
+    if (target) {
+      migration2 = target.replace(new RegExp(`${version2}-(.+)\\.js`), "$1");
+      migration2 = migrations.get(`${migration2}-down`);
+      if (migration2) {
+        const query = migration2.run(schema());
+        await query.on("query", () => {
+          process.stdout.write(sql`${query.toString()}`);
+          process.stdout.write(import_os7.EOL);
+        });
+        await connection("migrations").where({
+          version: version2
+        }).del();
+      }
+    }
+  }
+}
+
+// src/packages/cli/commands/dbseed.ts
+function dbseed() {
+  const load = createLoader(CWD);
+  const { database: config } = load("config");
+  const seed = load("seed");
+  const models = load("models");
+  return new database_default2({
+    config,
+    models,
+    path: CWD,
+    logger: new logger_default({
+      enabled: false
+    })
+  }).then((store) => store.connection.transaction(seed));
+}
+
+// src/packages/cli/commands/destroy.ts
+var import_os8 = require("os");
+var import_chalk11 = require("chalk");
+var import_inflection21 = require("inflection");
+async function destroyType(type, name) {
+  const normalizedType = type.toLowerCase();
+  let normalizedName = name;
+  let path6;
+  let migrations;
+  switch (normalizedType) {
+    case "model":
+      normalizedName = (0, import_inflection21.singularize)(normalizedName);
+      path6 = `app/${(0, import_inflection21.pluralize)(normalizedType)}/${normalizedName}.js`;
+      break;
+    case "migration":
+      migrations = await readdir(`${CWD}/db/migrate`);
+      normalizedName = migrations.find(
+        (file) => `${normalizedName}.js` === file.substr(17)
+      );
+      path6 = `db/migrate/${normalizedName}`;
+      break;
+    case "controller":
+    case "serializer":
+      normalizedName = (0, import_inflection21.pluralize)(normalizedName);
+      path6 = `app/${(0, import_inflection21.pluralize)(normalizedType)}/${normalizedName}.js`;
+      break;
+    case "middleware":
+      path6 = `app/${normalizedType}/${normalizedName}.js`;
+      break;
+    case "util":
+      path6 = `app/${(0, import_inflection21.pluralize)(normalizedType)}/${normalizedName}.js`;
+      break;
+    default:
+      return;
+  }
+  if (await exists(`${CWD}/${path6}`)) {
+    await rmrf_default(`${CWD}/${path6}`);
+    process.stdout.write(`${(0, import_chalk11.red)("remove")} ${path6}`);
+    process.stdout.write(import_os8.EOL);
+  }
+}
+async function destroy2({ type, name }) {
+  if (type === "resource") {
+    const routes = (await readFile(`${CWD}/app/routes.js`)).toString("utf8").split("\n").reduce((lines, line2) => {
+      const pattern = new RegExp(
+        `\\s*this.resource\\(('|"|\`)${(0, import_inflection21.pluralize)(name)}('|"|\`)\\);?`
+      );
+      return pattern.test(line2) ? lines : [...lines, line2];
+    }, []).join("\n");
+    await Promise.all([
+      destroyType("model", name),
+      destroyType("migration", `create-${(0, import_inflection21.pluralize)(name)}`),
+      destroyType("serializer", name),
+      destroyType("controller", name)
+    ]);
+    await writeFile(`${CWD}/app/routes.js`, routes);
+    process.stdout.write(`${(0, import_chalk11.green)("update")} app/routes.js`);
+    process.stdout.write(import_os8.EOL);
+  } else if (type === "model") {
+    await Promise.all([
+      destroyType(type, name),
+      destroyType("migration", `create-${(0, import_inflection21.pluralize)(name)}`)
+    ]);
+  } else {
+    await destroyType(type, name);
+  }
+}
+
+// src/packages/cli/commands/repl.ts
+var import_path14 = __toESM(require("path"));
+var import_repl = require("repl");
+function repl() {
+  return new Promise(async (resolve2) => {
+    const app = await Reflect.apply(require, null, [
+      import_path14.default.join(CWD, "dist", "boot")
+    ]);
+    const instance = (0, import_repl.start)({
+      prompt: "> "
+    });
+    instance.once("exit", resolve2);
+    Object.assign(instance.context, {
+      app,
+      logger: app.logger,
+      routes: app.router,
+      [app.constructor.name]: app,
+      ...Array.from(app.models).reduce(
+        (context, [, model2]) => ({
+          ...context,
+          [model2.name]: model2
+        }),
+        {}
+      ),
+      ...Array.from(app.controllers).reduce(
+        (context, [, controller2]) => ({
+          ...context,
+          [controller2.constructor.name]: controller2
+        }),
+        {}
+      ),
+      ...Array.from(app.serializers).reduce(
+        (context, [, serializer2]) => ({
+          ...context,
+          [serializer2.constructor.name]: serializer2
+        }),
+        {}
+      )
+    });
+  });
+}
+
+// src/packages/cli/commands/serve.ts
+var import_chalk13 = require("chalk");
+
+// src/packages/pm/cluster/index.ts
+var import_events2 = __toESM(require("events"));
+var import_os9 = __toESM(require("os"));
+var import_cluster2 = __toESM(require("cluster"));
+var import_path15 = require("path");
+var import_chalk12 = require("chalk");
+
+// src/utils/range.ts
+function* range(start, end) {
+  for (let i = start; i <= end; i += 1) {
+    yield i;
+  }
+}
+
+// src/packages/pm/cluster/index.ts
+var Cluster = class extends import_events2.default {
+  constructor({ path: path6, port, logger, maxWorkers }) {
+    super();
+    Object.defineProperties(this, {
+      path: {
+        value: path6,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      port: {
+        value: port,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      logger: {
+        value: logger,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      workers: {
+        value: /* @__PURE__ */ new Set(),
+        writable: false,
+        enumerable: true,
+        configurable: false
+      },
+      maxWorkers: {
+        value: maxWorkers || import_os9.default.cpus().length,
+        writable: false,
+        enumerable: true,
+        configurable: false
+      }
+    });
+    import_cluster2.default.setupMaster({
+      exec: (0, import_path15.join)(path6, "dist", "boot.js")
+    });
+    process.on("update", (changed) => {
+      changed.forEach(({ name: filename }) => {
+        logger.info(`${(0, import_chalk12.green)("update")} ${filename}`);
+      });
+      this.reload();
+    });
+    this.forkAll().then(() => this.emit("ready"));
+  }
+  fork(retry = true) {
+    return new Promise((resolve2) => {
+      if (this.workers.size < this.maxWorkers) {
+        const worker = import_cluster2.default.fork({
+          NODE_ENV,
+          PORT: this.port
+        });
+        const timeout = setTimeout(() => {
+          this.logger.info(line`
+            Removing worker process: ${(0, import_chalk12.red)(`${worker.process.pid}`)}
+          `);
+          clearTimeout(timeout);
+          worker.removeAllListeners();
+          worker.kill();
+          this.workers.delete(worker);
+          resolve2(worker);
+          if (retry) {
+            this.fork(false);
+          }
+        }, 3e4);
+        const handleError = (err) => {
+          if (err) {
+            this.logger.error(err);
+          }
+          this.logger.info(line`
+            Removing worker process: ${(0, import_chalk12.red)(`${worker.process.pid}`)}
+          `);
+          clearTimeout(timeout);
+          worker.removeAllListeners();
+          worker.kill();
+          this.workers.delete(worker);
+          resolve2(worker);
+        };
+        worker.on("message", (msg) => {
+          let data = {};
+          let message = msg;
+          if (typeof message === "object") {
+            data = omit(message, "message");
+            message = message.message;
+          }
+          switch (message) {
+            case "ready":
+              this.logger.info(line`
+                Adding worker process: ${(0, import_chalk12.green)(`${worker.process.pid}`)}
+              `);
+              this.workers.add(worker);
+              clearTimeout(timeout);
+              worker.removeListener("error", handleError);
+              resolve2(worker);
+              break;
+            case "error":
+              handleError(data.error);
+              break;
+            default:
+              break;
+          }
+        });
+        worker.once("error", handleError);
+        worker.once("exit", (code) => {
+          const {
+            process: { pid }
+          } = worker;
+          if (typeof code === "number") {
+            this.logger.info(line`
+              Worker process: ${(0, import_chalk12.red)(`${pid}`)} exited with code ${code}
+            `);
+          }
+          this.logger.info(`Removing worker process: ${(0, import_chalk12.red)(`${pid}`)}`);
+          clearTimeout(timeout);
+          worker.removeAllListeners();
+          this.workers.delete(worker);
+          this.fork();
+        });
+      }
+    });
+  }
+  shutdown(worker) {
+    return new Promise((resolve2) => {
+      this.workers.delete(worker);
+      const timeout = setTimeout(() => worker.kill(), 5e3);
+      worker.once("disconnect", () => {
+        worker.kill();
+      });
+      worker.once("exit", () => {
+        resolve2(worker);
+        clearTimeout(timeout);
+      });
+      worker.send("shutdown");
+      worker.disconnect();
+    });
+  }
+  reload() {
+    if (this.workers.size) {
+      const groups = Array.from(this.workers).reduce((arr, item, idx, src) => {
+        if ((idx + 1) % 2) {
+          const group = src.slice(idx, idx + 2);
+          return [
+            ...arr,
+            () => Promise.all(group.map((worker) => this.shutdown(worker)))
+          ];
+        }
+        return arr;
+      }, []);
+      return composeAsync(...groups)();
+    }
+    return this.fork();
+  }
+  forkAll() {
+    return Promise.race(
+      Array.from(range(1, this.maxWorkers)).map(() => this.fork())
+    );
+  }
+};
+var cluster_default = Cluster;
+
+// src/packages/pm/index.ts
+function createCluster({
+  path: path6,
+  port,
+  logger,
+  maxWorkers
+}) {
+  return new cluster_default({
+    path: path6,
+    port,
+    logger,
+    maxWorkers
+  });
+}
+
+// src/packages/cli/commands/serve.ts
+async function serve({
+  hot = NODE_ENV === "development",
+  cluster: cluster3 = false,
+  useStrict = false
+}) {
+  const load = createLoader(CWD);
+  const { logging } = load("config");
+  const logger = new logger_default(logging);
+  if (hot) {
+    const watcher = await watch(CWD);
+    watcher.on("change", async (changed) => {
+      await build2(useStrict);
+      process.emit("update", changed);
+    });
+  }
+  createCluster({
+    logger,
+    path: CWD,
+    port: PORT,
+    maxWorkers: cluster3 ? void 0 : 1
+  }).once("ready", () => {
+    logger.info(`Lumen Server listening on port: ${(0, import_chalk13.cyan)(`${PORT}`)}`);
+  });
+}
+
+// src/packages/cli/commands/test.ts
+var import_os10 = require("os");
+function test() {
+  process.stdout.write("Coming Soon!");
+  process.stdout.write(import_os10.EOL);
+  return Promise.resolve();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  create,
+  dbcreate,
+  dbdrop,
+  dbmigrate,
+  dbrollback,
+  dbseed,
+  destroy,
+  generate,
+  repl,
+  serve,
+  test
+});
+//# sourceMappingURL=cli.cjs.map