velocious 1.0.430 → 1.0.432

package/build/utils/rest-args-error.js

@@ -0,0 +1,14 @@
+// @ts-check
+
+/**
+ * Runs rest args error.
+ * @param {object} restArgs - Rest args.
+ * @returns {void} - No return value.
+ */
+export default function restArgsError(restArgs) {
+  const restArgsKeys = Object.keys(restArgs)
+
+  if (restArgsKeys.length > 0) {
+    throw new Error(`Unknown arguments: ${restArgsKeys.join(", ")}`)
+  }
+}

package/build/utils/singularize-model-name.js

@@ -0,0 +1,18 @@
+import * as inflection from "inflection"
+
+/**
+ * Runs singularize model name.
+ * @param {string} modelName - Model name.
+ * @returns {string} - The singularize model name.
+ */
+export default function singularizeModelName(modelName) {
+  const words = inflection.underscore(modelName).split("_")
+  const lastWord = words.pop()
+
+  if (!lastWord) throw new Error(`No words? ${words.join(", ")}`)
+
+  const lastSingularizedWord = inflection.singularize(lastWord)
+  const singularizedClassName = inflection.camelize(`${words.join("_")}_${lastSingularizedWord}`)
+
+  return singularizedClassName
+}

package/build/utils/split-sql-statements.js

@@ -0,0 +1,88 @@
+// @ts-check
+
+/**
+ * Splits structure SQL into executable statements while keeping semicolons inside strings, identifiers, and comments intact.
+ * @param {string} sql - SQL string.
+ * @returns {string[]} - SQL statements.
+ */
+export default function splitSqlStatements(sql) {
+  /** @type {string[]} */
+  const statements = []
+  let current = ""
+  let inSingleQuote = false
+  let inDoubleQuote = false
+  let inBacktick = false
+  let inLineComment = false
+  let inBlockComment = false
+
+  for (let index = 0; index < sql.length; index++) {
+    const char = sql[index]
+    const nextChar = sql[index + 1]
+    const previousChar = sql[index - 1]
+
+    current += char
+
+    if (inLineComment) {
+      if (char == "\n") inLineComment = false
+
+      continue
+    }
+
+    if (inBlockComment) {
+      if (previousChar == "*" && char == "/") inBlockComment = false
+
+      continue
+    }
+
+    if (!inSingleQuote && !inDoubleQuote && !inBacktick) {
+      if (char == "-" && nextChar == "-") {
+        inLineComment = true
+        continue
+      }
+
+      if (char == "/" && nextChar == "*") {
+        inBlockComment = true
+        continue
+      }
+    }
+
+    if (char == "'" && !inDoubleQuote && !inBacktick && previousChar != "\\") {
+      if (inSingleQuote && nextChar == "'") {
+        current += nextChar
+        index += 1
+      } else {
+        inSingleQuote = !inSingleQuote
+      }
+      continue
+    }
+
+    if (char == "\"" && !inSingleQuote && !inBacktick && previousChar != "\\") {
+      if (inDoubleQuote && nextChar == "\"") {
+        current += nextChar
+        index += 1
+      } else {
+        inDoubleQuote = !inDoubleQuote
+      }
+      continue
+    }
+
+    if (char == "`" && !inSingleQuote && !inDoubleQuote && previousChar != "\\") {
+      inBacktick = !inBacktick
+      continue
+    }
+
+    if (char == ";" && !inSingleQuote && !inDoubleQuote && !inBacktick) {
+      const trimmed = current.trim()
+
+      if (trimmed) statements.push(trimmed)
+
+      current = ""
+    }
+  }
+
+  const trimmed = current.trim()
+
+  if (trimmed) statements.push(trimmed)
+
+  return statements
+}

package/build/utils/to-import-specifier.js

@@ -0,0 +1,53 @@
+// @ts-check
+
+import path from "path"
+import {pathToFileURL} from "url"
+
+/**
+ * Runs is windows absolute path.
+ * @param {string} value - Path or import specifier.
+ * @returns {boolean} - Whether value is a Windows absolute path.
+ */
+function isWindowsAbsolutePath(value) {
+  return /^[a-zA-Z]:[\\/]/.test(value) || value.startsWith("\\\\")
+}
+
+/**
+ * Runs windows path to file url.
+ * @param {string} windowsPath - Windows absolute path.
+ * @returns {string} - File URL.
+ */
+function windowsPathToFileUrl(windowsPath) {
+  const normalized = windowsPath.replaceAll("\\", "/")
+
+  if (normalized.startsWith("//")) {
+    const uncPath = normalized.replace(/^\/+/, "")
+    const [host, ...pathParts] = uncPath.split("/")
+    const url = new URL(`file://${host}/`)
+
+    url.pathname = `/${pathParts.join("/")}`
+
+    return url.href
+  }
+
+  const url = new URL("file:///")
+
+  url.pathname = `/${normalized}`
+
+  return url.href
+}
+
+/**
+ * Converts a filesystem path to a dynamic-import safe specifier across platforms.
+ * Leaves package names and relative specifiers unchanged.
+ * @param {string} value - Import specifier or filesystem path.
+ * @returns {string} - Import specifier safe for dynamic import.
+ */
+export default function toImportSpecifier(value) {
+  if (value.match(/^(node|data|file):/)) return value
+  if (value.startsWith("./") || value.startsWith("../")) return value
+  if (isWindowsAbsolutePath(value)) return windowsPathToFileUrl(value)
+  if (path.isAbsolute(value)) return pathToFileURL(value).href
+
+  return value
+}

package/build/utils/with-tracked-stack-async-hooks.js

@@ -0,0 +1,103 @@
+// @ts-check
+
+import {AsyncLocalStorage} from "node:async_hooks"
+
+/**
+ * Defines asyncLocalStorage.
+  @type {import("node:async_hooks").AsyncLocalStorage<Array<string[]>> | undefined} */
+let asyncLocalStorage
+
+/**
+ * Tracked stack global.
+  @type {{withTrackedStack?: {addTrackedStackToError: (error: Error) => void, withTrackedStack: (arg1: string | (() => Promise<?>), arg2?: (() => Promise<?>) | Error) => Promise<?>}}} */
+const trackedStackGlobal = /**
+                            * Narrows the runtime value to the documented type.
+                             @type {?} */ (globalThis)
+
+if (AsyncLocalStorage) {
+  asyncLocalStorage = new AsyncLocalStorage()
+}
+
+/**
+ * Runs add tracked stack to error.
+ * @param {Error} error - Error to annotate with a tracked stack.
+ */
+function addTrackedStackToError(error) {
+  // Not supported
+  if (!asyncLocalStorage) return
+
+  const parentStacks = asyncLocalStorage.getStore() || []
+  const additionalStackLines = []
+
+  for (const parentStack of parentStacks) {
+    for (const parentStackLine of parentStack) {
+      additionalStackLines.push(parentStackLine)
+    }
+  }
+
+  // Replace the error message on the first line with this string
+  error.stack += "\n" + additionalStackLines.join("\n")
+}
+
+/**
+ * Runs with tracked stack.
+ * @param {(() => Promise<?>) | string} arg1 - Arg1.
+ * @param {(() => Promise<?>) | Error} [arg2] - Arg2.
+ * @returns {Promise<?>} - Resolves with the callback result.
+ */
+async function withTrackedStack(arg1, arg2) {
+  /**
+   * Defines callback.
+    @type {() => Promise<?>} */
+  let callback
+
+  /**
+   * Defines stack.
+    @type {string} */
+  let stack
+
+  if (typeof arg2 == "function" && typeof arg1 == "string") {
+    callback = /**
+                * Narrows the runtime value to the documented type.
+                 @type {() => Promise<?>} */ (arg2)
+    stack = arg1
+  } else {
+    callback = /**
+                * Narrows the runtime value to the documented type.
+                 @type {() => Promise<?>} */ (arg1)
+    stack = Error().stack || ""
+  }
+
+  // Not supported
+  if (!asyncLocalStorage) return await callback()
+
+  const parentStacks = asyncLocalStorage.getStore() || []
+  const additionalStackLines = []
+  const currentStackLines = stack.split("\n")
+
+  currentStackLines[0] = "    [WITH TRACKED STACK]"
+
+  for (let i = currentStackLines.length; i >= 0; i--) {
+    const stackLine = currentStackLines[i]
+
+    additionalStackLines.unshift(stackLine)
+
+    if (stackLine == "    [WITH TRACKED STACK]") {
+      break
+    }
+  }
+
+  const newStacks = [additionalStackLines, ...parentStacks]
+
+  return await asyncLocalStorage.run(newStacks, async () => {
+    return await callback()
+  })
+}
+
+if (trackedStackGlobal.withTrackedStack) {
+  console.warn("globalThis.withTrackedStack was already defined")
+} else {
+  trackedStackGlobal.withTrackedStack = {addTrackedStackToError, withTrackedStack}
+}
+
+export {addTrackedStackToError, withTrackedStack}

package/build/utils/with-tracked-stack.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+/**
+ * Tracked stack global.
+  @type {{withTrackedStack?: {withTrackedStack?: (stack: string | undefined, fn: () => Promise<?>) => Promise<?>, addTrackedStackToError?: (error: Error) => void}}} */
+const trackedStackGlobal = /**
+                            * Narrows the runtime value to the documented type.
+                             @type {?} */ (globalThis)
+
+/**
+ * Runs add tracked stack to error.
+ * @param {Error} error - Error to annotate with a tracked stack.
+ */
+function addTrackedStackToError(error) {
+  trackedStackGlobal.withTrackedStack?.addTrackedStackToError?.(error)
+}
+
+/**
+ * Runs with tracked stack.
+ * @param {string | (() => Promise<?>)} stackOrCallback - Stack string or callback.
+ * @param {(() => Promise<?>)} [callback] - Callback to execute.
+ * @returns {Promise<?>} - Resolves with value.
+ */
+async function withTrackedStack(stackOrCallback, callback) {
+  const tracked = trackedStackGlobal.withTrackedStack?.withTrackedStack
+  const resolvedCallback = callback ?? /**
+                                        * Narrows the runtime value to the documented type.
+                                         @type {() => Promise<?>} */ (stackOrCallback)
+  const stack = typeof stackOrCallback == "string" ? stackOrCallback : undefined
+
+  if (tracked) {
+    return await tracked(stack, resolvedCallback)
+  }
+
+  return await resolvedCallback()
+}
+
+export {addTrackedStackToError, withTrackedStack}

package/build/velocious-error.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+/** Framework error with optional client-safe message exposure flag. */
+export default class VelociousError extends Error {
+  /**
+   * Runs constructor.
+   * @param {string} message - Error message.
+   * @param {object} [args] - Options.
+   * @param {?} [args.cause] - Error cause.
+   * @param {string} [args.code] - Optional error code.
+   * @param {boolean} [args.safeToExpose] - Whether the message is safe to return to clients.
+   */
+  constructor(message, args = {}) {
+    const {cause, code, safeToExpose = false} = args
+
+    super(message, {cause})
+
+    this.name = "VelociousError"
+    this.code = code
+    this.safeToExpose = safeToExpose
+  }
+
+  /**
+   * Runs safe.
+   * @param {string} message - Error message.
+   * @param {object} [args] - Options.
+   * @param {?} [args.cause] - Error cause.
+   * @param {string} [args.code] - Optional error code.
+   * @returns {VelociousError} - Client-safe error instance.
+   */
+  static safe(message, args = {}) {
+    return new VelociousError(message, {...args, safeToExpose: true})
+  }
+}

package/index.js

@@ -0,0 +1 @@
+export {}

package/package.json

@@ -3,16 +3,22 @@
     "velocious": "build/bin/velocious.js"
   },
   "name": "velocious",
-  "version": "1.0.430",
+  "version": "1.0.432",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "files": [
-    "build/**"
+    "bin/**",
+    "build/**",
+    "index.js",
+    "scripts/**",
+    "src/**",
+    "tsconfig.json"
   ],
   "scripts": {
     "all-checks": "npm run lint && npm run test",
     "build": "node scripts/clean-build.js && npm run compile",
-    "compile": "tsc -b && npm run copy:ejs && npm run copy:templates && node scripts/ensure-bin-executable.js",
+    "compile": "tsc -b && npm run copy:js && npm run copy:ejs && npm run copy:templates && node scripts/ensure-bin-executable.js",
+    "copy:js": "cpy \"index.js\" build && cpy \"bin/**/*.js\" build/bin && cpy \"src/**/*.js\" build --parents",
     "copy:ejs": "cpy \"src/routes/**/*.ejs\" build/src/routes",
     "copy:templates": "cpy \"src/templates/**/*.js\" build/src/templates",
     "fallow": "fallow dead-code --baseline fallow-baselines/dead-code.json --fail-on-issues --quiet && fallow dupes --baseline fallow-baselines/dupes.json --fail-on-issues --quiet && fallow health --baseline fallow-baselines/health.json --quiet",
@@ -104,7 +110,7 @@
     "require-context": "^1.1.0",
     "sqlite": "^5.1.1",
     "sqlite3": "^6.0.1",
-    "system-testing": "^1.0.83",
+    "system-testing": "^1.0.108",
     "tedious": "^19.1.3",
     "typescript": "^6.0.2",
     "uniqunize": "^1.0.3"

package/scripts/clean-build.js

@@ -0,0 +1,8 @@
+import fs from "node:fs/promises"
+
+/** Removes the generated build directory. */
+async function main() {
+  await fs.rm("build", {recursive: true, force: true})
+}
+
+await main()

package/scripts/ensure-bin-executable.js

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises"
+import path from "node:path"
+
+/** Ensures the built CLI entrypoint has execute permissions on POSIX. */
+async function main() {
+  if (process.platform === "win32") return
+
+  const binPath = path.join("build", "bin", "velocious.js")
+
+  await fs.chmod(binPath, 0o755)
+}
+
+await main()

package/scripts/run-tests.js

@@ -0,0 +1,37 @@
+import path from "node:path"
+import process from "node:process"
+import {spawn} from "node:child_process"
+import {fileURLToPath} from "node:url"
+
+/** Runs the Velocious test command from the dummy app with cross-platform env setup. */
+async function main() {
+  const __filename = fileURLToPath(import.meta.url)
+  const scriptsDirectory = path.dirname(__filename)
+  const projectDirectory = path.resolve(scriptsDirectory, "..")
+  const dummyDirectory = path.join(projectDirectory, "spec", "dummy")
+  const testDirectory = path.resolve(dummyDirectory, "..")
+  const cliPath = path.join(projectDirectory, "bin", "velocious.js")
+  const args = ["test", ...process.argv.slice(2)]
+
+  await new Promise((resolve, reject) => {
+    const childProcess = spawn(process.execPath, [cliPath, ...args], {
+      cwd: dummyDirectory,
+      env: {...process.env, VELOCIOUS_TEST_DIR: testDirectory},
+      stdio: "inherit"
+    })
+
+    childProcess.once("error", reject)
+    childProcess.once("close", (code, signal) => {
+      if (signal) {
+        reject(new Error(`Test process terminated by signal: ${signal}`))
+        return
+      }
+
+      resolve(code ?? 1)
+    })
+  }).then((code) => {
+    process.exit(/** @type {number} */ (code))
+  })
+}
+
+await main()