lumen-framework 3.0.0

package/dist/types/packages/server/request/parser/utils/parse-nested-object.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function parseNestedObject(source: Record<string, unknown>): Record<string, unknown>;

package/dist/types/packages/server/request/parser/utils/parse-read.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from '../../interfaces';
+/**
+ * @private
+ */
+export default function parseRead({ method, url: { query } }: Request): Record<string, unknown>;

package/dist/types/packages/server/request/parser/utils/parse-write.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from '../../interfaces';
+/**
+ * @private
+ */
+export default function parseWrite(req: Request): Promise<Record<string, unknown>>;

package/dist/types/packages/server/request/utils/get-domain.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from '../interfaces';
+/**
+ * @private
+ */
+export default function getDomain({ headers, connection: { encrypted } }: Request): string;

package/dist/types/packages/server/responder/index.d.ts

@@ -0,0 +1,5 @@
+import type { Request, Response } from '../index';
+/**
+ * @private
+ */
+export declare function createResponder(req: Request, res: Response): (data?: unknown) => void;

package/dist/types/packages/server/responder/utils/data-for.d.ts

@@ -0,0 +1,5 @@
+import type { JSONAPI$Document } from '../../../jsonapi';
+/**
+ * @private
+ */
+export default function dataFor(status: number, err?: Error): string | JSONAPI$Document;

package/dist/types/packages/server/responder/utils/has-content-type.d.ts

@@ -0,0 +1,2 @@
+import type { Response } from '../../index';
+export default function hasContentType(res: Response): boolean;

package/dist/types/packages/server/responder/utils/normalize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @private
+ */
+export default function normalize(data?: unknown): {
+    statusCode: number | undefined;
+    data: string;
+};

package/dist/types/packages/server/response/index.d.ts

@@ -0,0 +1,5 @@
+import type { Response, Response$opts } from './interfaces';
+/**
+ * @private
+ */
+export declare function createResponse(res: any, opts: Response$opts): Response;

package/dist/types/packages/server/response/interfaces.d.ts

@@ -0,0 +1,22 @@
+import type { Writable } from 'stream';
+import type Logger from '../../logger';
+type Response$stat = {
+    type: string;
+    name: string;
+    duration: number;
+    controller: string;
+};
+export type Response$opts = {
+    logger: Logger;
+};
+export interface Response extends Writable {
+    [key: string]: unknown;
+    stats: Array<Response$stat>;
+    logger: Logger;
+    statusCode: number;
+    statusMessage: string;
+    getHeader(name: string): string | void;
+    setHeader(name: string, value: string): void;
+    removeHeader(name: string): void;
+}
+export {};

package/dist/types/packages/server/utils/create-server-error.d.ts

@@ -0,0 +1,7 @@
+import type { Server$Error } from '../interfaces';
+type Constructor<T> = new (...args: Array<any>) => T;
+/**
+ * @private
+ */
+export default function createServerError<T extends object>(Target: Constructor<T>, statusCode: number): Constructor<T & Server$Error>;
+export {};

package/dist/types/packages/server/utils/set-cors-headers.d.ts

@@ -0,0 +1,3 @@
+import type { Response } from '../index';
+import type { Server$cors } from '../interfaces';
+export default function setCORSHeaders(res: Response, { origin, methods, headers, enabled }: Server$cors): void;

package/dist/types/packages/server/utils/validate-accept.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function validateAccept(contentType?: string): true;

package/dist/types/packages/server/utils/validate-content-type.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function validateContentType(contentType?: string): true;

package/dist/types/packages/template/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Used as a template tag, so `strings` arrives as a TemplateStringsArray —
+ * typed as `readonly string[]`, which also accepts a plain array.
+ *
+ * @private
+ */
+export default function template(strings: readonly string[], ...values: unknown[]): string;
+export { default as insertValues } from './utils/insert-values';

package/dist/types/packages/template/utils/insert-values.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function insertValues(strings: readonly string[], ...values: unknown[]): string;

package/dist/types/utils/chain.d.ts

@@ -0,0 +1,5 @@
+import type { Chain } from '../interfaces';
+/**
+ * @private
+ */
+export default function chain<T>(source: T): Chain<T>;

package/dist/types/utils/compact.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Removes null/undefined entries from an array or object.
+ *
+ * Overloaded because the two inputs behave differently: an array keeps its
+ * element type, while an object may lose keys — hence `Partial<T>` rather than
+ * Flow's `T`.
+ *
+ * @private
+ */
+export default function compact<T>(source: T[]): T[];
+export default function compact<T extends object>(source: T): Partial<T>;

package/dist/types/utils/compose.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A single stage of a composed pipeline.
+ *
+ * @private
+ */
+type Stage = (value: any) => any;
+/**
+ * @private
+ */
+export declare function tap<T>(input: T): T;
+/**
+ * @private
+ */
+export declare function compose<T, U>(main: (input: any) => U, ...etc: Stage[]): (input: T) => U;
+/**
+ * @private
+ */
+export declare function composeAsync<T, U>(main: (input: any) => Promise<U>, ...etc: Stage[]): (input: T | Promise<T>) => Promise<U>;
+export {};

package/dist/types/utils/create-query-string.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A replacement for querystring.stringify that supports nested objects.
+ *
+ * @private
+ */
+export default function createQueryString(src: Record<string, unknown>, prop?: string): string;

package/dist/types/utils/diff.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export declare function map<K, V>(a: Map<K, V>, b: Map<K, V>): Map<K, V>;

package/dist/types/utils/entries.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function entries<T>(source: Record<string, T>): Array<[string, T]>;

package/dist/types/utils/env.d.ts

@@ -0,0 +1,3 @@
+export declare const isDevelopment: () => boolean;
+export declare const isProduction: () => boolean;
+export declare const isTest: () => boolean;

package/dist/types/utils/exec.d.ts

@@ -0,0 +1,5 @@
+import type { ExecOptions } from 'child_process';
+/**
+ * @private
+ */
+export default function exec(cmd: string, opts?: ExecOptions): Promise<[string, string]>;

package/dist/types/utils/github.d.ts

@@ -0,0 +1,9 @@
+type Options = {
+    line?: number;
+    branch?: string;
+};
+/**
+ * @private
+ */
+export declare function fileLink(path: string, opts?: Options): string;
+export {};

package/dist/types/utils/has-own-property.d.ts

@@ -0,0 +1 @@
+export default function hasOwnProperty(target: object, key: string): boolean;

package/dist/types/utils/insert.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function insert<T, U extends T[]>(target: U, items: T[]): U;

package/dist/types/utils/is-buffer.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function isBuffer(value: unknown): value is Buffer;

package/dist/types/utils/is-null.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function isNull(value: unknown): value is null;

package/dist/types/utils/is-object.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Determine wether or not a value is an Object.
+ *
+ * @example
+ * const a = null;
+ * const b = [];
+ * const c = {};
+ *
+ * console.log(typeof a, typeof b, typeof c);
+ * // => 'object', 'object', 'object' 👎
+ *
+ * console.log(isObject(a), isObject(b), isObject(c));
+ * // => false, false, true 👍
+ *
+ * @private
+ */
+export default function isObject(value: unknown): value is Record<string, unknown>;

package/dist/types/utils/is-undefined.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function isUndefined(value: unknown): value is undefined;

package/dist/types/utils/k.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A utility function that always returns `this` based on it's current
+ * context.
+ *
+ * A common use case for the K function is a default parameter for optional
+ * callback functions or general function arguments.
+ *
+ * @private
+ */
+export default function K(this: unknown): unknown;

package/dist/types/utils/map-to-object.d.ts

@@ -0,0 +1 @@
+export default function mapToObject<T>(source: Map<string, T>): Record<string, T>;

package/dist/types/utils/merge.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function merge<T extends object, U extends object>(dest: T, source: U): T & U;

package/dist/types/utils/omit.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns a copy of `src` without `omitted` keys.
+ *
+ * Typed as `Partial<T>` rather than Flow's `T`, since the omitted keys are by
+ * definition absent from the result.
+ *
+ * @private
+ */
+export default function omit<T extends object>(src: T, ...omitted: string[]): Partial<T>;

package/dist/types/utils/pick.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns a copy of `src` containing only `keys` whose values are defined.
+ *
+ * The result is `Partial<T>` rather than Flow's `T`: keys may be dropped, both
+ * because the caller asked for a subset and because undefined values are
+ * filtered out. The cast is confined to the return, where the dynamic key
+ * access makes the shape unknowable to the compiler.
+ *
+ * @private
+ */
+export default function pick<T extends object>(src: T, ...keys: string[]): Partial<T>;

package/dist/types/utils/present.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function present(...values: unknown[]): boolean;

package/dist/types/utils/promise-hash.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves every value of an object, returning an object of the same shape with
+ * each promise unwrapped.
+ *
+ * @private
+ */
+export default function promiseHash<T extends Record<string, unknown>>(promises: T): Promise<{
+    [K in keyof T]: Awaited<T[K]>;
+}>;

package/dist/types/utils/proxy.d.ts

@@ -0,0 +1,6 @@
+type ProxyGet<T extends object> = (target: T, key: string, receiver: unknown) => unknown;
+/**
+ * @private
+ */
+export declare function trapGet<T extends object>(traps: Record<string, unknown>): ProxyGet<T>;
+export {};

package/dist/types/utils/range.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function range(start: number, end: number): Generator<number, void, void>;

package/dist/types/utils/set-type.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Escape hatch that existed to coerce Flow into accepting the return type of a
+ * polymorphic higher-order function.
+ *
+ * NOTE: this util is a Flow-era crutch. TypeScript's generics express the same
+ * intent directly, so calls to `setType` should be removed as their callers are
+ * converted — at which point this file can go away entirely.
+ *
+ * @private
+ */
+export default function setType<T>(fn: () => T): T;

package/dist/types/utils/sleep.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function sleep(amount: number): Promise<void>;

package/dist/types/utils/stringify.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function stringify(value?: unknown, spaces?: number): string;

package/dist/types/utils/transform-keys.d.ts

@@ -0,0 +1,29 @@
+type Transformer = (key: string) => string;
+/**
+ * Rewrites an object's keys with `transformer`.
+ *
+ * Overloaded rather than Flow's `T -> T`, which was inaccurate: transforming
+ * keys produces a differently-shaped object, so the object form returns
+ * `Record<string, unknown>`. Arrays are passed through as a shallow copy (their
+ * keys are not transformed), so they keep their element type.
+ *
+ * @private
+ */
+export declare function transformKeys<T>(source: T[], transformer: Transformer, deep?: boolean): T[];
+export declare function transformKeys(source: object, transformer: Transformer, deep?: boolean): Record<string, unknown>;
+/**
+ * @private
+ */
+export declare function camelizeKeys<T>(source: T[], deep?: boolean): T[];
+export declare function camelizeKeys(source: object, deep?: boolean): Record<string, unknown>;
+/**
+ * @private
+ */
+export declare function dasherizeKeys<T>(source: T[], deep?: boolean): T[];
+export declare function dasherizeKeys(source: object, deep?: boolean): Record<string, unknown>;
+/**
+ * @private
+ */
+export declare function underscoreKeys<T>(source: T[], deep?: boolean): T[];
+export declare function underscoreKeys(source: object, deep?: boolean): Record<string, unknown>;
+export {};

package/dist/types/utils/try-catch.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A utility function used for wrapping async code that would otherwise need a
+ * try-catch block.
+ *
+ * V8 deoptimizes functions when running into try-catch catch due to the
+ * unpredictable nature of the code. The `tryCatch` utility function is a way
+ * to "have your cake and eat it too". Since the inner function (`fn`) will not
+ * become deoptimized by V8 for including a standard try-catch block, we don't
+ * have to sacrifice as much perf for error handling expensive computations.
+ *
+ * The `tryCatch` utility is also very useful when you want to perform a noop
+ * when an error is thrown as the catch argument (`rescue`) is optional unlike
+ * a traditional try-catch block.
+ *
+ * @example
+ * tryCatch(() => {
+ *   const n = Math.floor(Math.random() * 6);
+ *
+ *   if (n >= 4) {
+ *     throw new Error('You lose!');
+ *   } else {
+ *     return Promise.resolve(n);
+ *   }
+ * }, err => {
+ *   console.error(err);
+ * }).then(luckyNumber => {
+ *   console.log(`Your lucky number is ${luckyNumber}.`);
+ * });
+ *
+ * @private
+ */
+export default function tryCatch<T>(fn: () => Promise<T>, rescue?: (err: unknown) => unknown): Promise<T | undefined>;
+/**
+ * A syncronous implementation of the `tryCatch` utility.
+ *
+ * @example
+ * const luckyNumber = tryCatchSync(() => {
+ *   const n = Math.floor(Math.random() * 6);
+ *
+ *   if (n >= 4) {
+ *     throw new Error('You lose!');
+ *   } else {
+ *     return n;
+ *   }
+ * }, err => {
+ *   console.error(err);
+ * });
+ *
+ * if (luckyNumber) {
+ *   console.log(`Your lucky number is ${luckyNumber}.`);
+ * }
+ *
+ * @private
+ */
+export declare function tryCatchSync<T>(fn: () => T, rescue?: (err: unknown) => unknown): T | undefined;

package/dist/types/utils/underscore.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function underscore(source?: string, upper?: boolean): string;

package/dist/types/utils/uniq.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @private
+ */
+export default function uniq<T>(src: T[], ...keys: string[]): T[];

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "lumen-framework",
+  "version": "3.0.0",
+  "description": "Build scalable, Node.js-powered REST APIs with almost no code.",
+  "repository": "github:nickschot/lux",
+  "keywords": [
+    "mvc",
+    "api",
+    "lux",
+    "lumen",
+    "jsonapi",
+    "json-api",
+    "rest",
+    "framework"
+  ],
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "bin": {
+    "lumen": "bin/lumen"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "build:types": "tsc -p tsconfig.build.json",
+    "prepack": "pnpm run build && pnpm run build:types",
+    "clean": "shx rm -rf coverage dist test/test-app/dist",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "debugger": "node --enable-source-maps test/utils/debugger/dist/debug.js",
+    "build:debugger": "node test/utils/debugger/build.mjs"
+  },
+  "author": "Nick Schot <nickschot@gmail.com>",
+  "contributors": [
+    {
+      "name": "Zachary Golba",
+      "url": "https://github.com/zacharygolba"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nickschot/lux/issues"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "packageManager": "pnpm@10.34.5",
+  "dependencies": {
+    "ansi-regex": "^5.0.1",
+    "chalk": "^4.1.2",
+    "commander": "^2.20.3",
+    "esbuild": "^0.28.1",
+    "fb-watchman": "^2.0.2",
+    "inflection": "^1.13.4",
+    "knex": "^3.3.0",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.5",
+    "@types/inflection": "1.13.2",
+    "@types/node": "^20.19.43",
+    "@vitest/coverage-v8": "^4.1.10",
+    "eslint": "^9.39.5",
+    "eslint-config-prettier": "^10.1.8",
+    "faker": "4.1.0",
+    "globals": "^17.7.0",
+    "lumen-framework": "link:.",
+    "node-fetch": "^2.7.0",
+    "prettier": "^3.9.5",
+    "shx": "^0.3.4",
+    "sinon": "2.2.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.64.0",
+    "vitest": "^4.1.10"
+  },
+  "volta": {
+    "node": "20.20.2"
+  }
+}