stacks 0.58.73 → 0.59.2

package/core/error-handling/README.md

@@ -1,131 +0,0 @@
-# Stacks Error Handling
-
-Similar to the way Rust handles errors and other functional programming languages.
-
->Encode failure into your program. This package contains a Result type that represents either success (`Ok`) or failure (`Err`).
->
->For asynchronous tasks, this package offers a `ResultAsync` class which wraps a `Promise<Result<T, E>>` and gives you the same level of expressivity and control as a regular `Result<T, E>`.
->
->`ResultAsync` is "thenable" meaning it behaves exactly like a native `Promise<Result>`, except you have access to the same methods that Result provides without having to `await` or `.then` the promise. _- neverthrow_
-
-Read more about the API in the documentation [here](https://github.com/supermacro/neverthrow).
-
-## ☘️ Features
-
-Currently, a wrapper of the `neverthrow` API.
-
-- Type-Safe Errors
-- Encode failure into your program
-
-## 🤖 Usage
-
-```bash
-bun install -d @stacksjs/error-handling
-```
-
-You can now use it in your project:
-
-```js
-import {
-  Err,
-  Ok,
-  Result,
-  ResultAsync,
-  err,
-  errAsync,
-  fromPromise,
-  fromSafePromise,
-  fromThrowable,
-  ok,
-  okAsync,
-} from '@stacksjs/error-handling'
-
-// ...
-```
-
-### Example #1
-
-```js
-const result = ok({ myData: 'test' }) // instance of `Ok`
-
-result.isOk() // true
-result.isErr() // false
-```
-
-### Example #2
-
-```js
-const command = 'rimraf ./bun.lockb ./node_modules ./core/**/dist'
-const result = await runCommand(command, options)
-
-if (result.isOk()) {
-  log.success('Cleaned up')
-  process.exit(ExitCode.Success)
-}
-
-log.error(result.error)
-process.exit(ExitCode.FatalError)
-```
-
-Learn more in the [docs](https://github.com/supermacro/neverthrow/wiki).
-
-## 🧪 Testing
-
-```bash
-bun test
-```
-
-## 🤗 Motivation
-
-As from the [HackerNews thread](https://news.ycombinator.com/item?id=26191006) relating to "Where Everything Went Wrong: Error Handling and Error Messages in Rust (2020)":
-
-```
-Error handling has been wrong since the beginning, and has continued to be wrong ever since.
-
-First, we had error codes. Except these were wrong because people forget all the time to check them.
-
-Then we had exceptions, which solved the problem of people forgetting to check by crashing the app.
-
-Then the Java team got the bright idea to have checked exceptions, which at first helped to mitigate crashes
-from uncaught exception, but caused an explosion in thrown exception signatures, culminating in "catch Throwable".
-
-Back to square one.
-
-Then we got multi-return error objects, maybes, panics, and all sorts of bright ideas that fail to understand the basic premises of errors:
-
-  Any error system that relies upon developer discipline will fail because errors will be missed.
-
-  Any error system that handles all errors the same way will fail because there are some errors we can ignore,
-  and some errors we must not ignore. And what's ignorable/retriable to one project is not ignorable/retriable to another.
-
-Attempting to get the complete set of error types that any given call may raise is a fool's errand because of the halting
-problem it eventually invokes. Forcing people to provide such a list results in the Java problem for the same reason.
-
-It's a hard problem, which is why no one has solved it yet.
-```
-
-Quote from user [kstenerud](https://news.ycombinator.com/user?id=kstenerud).
-
-## 📈 Changelog
-
-Please see our [releases](https://github.com/stacksjs/stacks/releases) page for more information on what has changed recently.
-
-## 🚜 Contributing
-
-Please review the [Contributing Guide](https://github.com/stacksjs/contributing) for details.
-
-## 🏝 Community
-
-For help, discussion about best practices, or any other conversation that would benefit from being searchable:
-
-[Discussions on GitHub](https://github.com/stacksjs/stacks/discussions)
-
-For casual chit-chat with others using this package:
-
-[Join the Stacks Discord Server](https://discord.gg/stacksjs)
-
-## 📄 License
-
-The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
-
-Made with 💙

package/core/error-handling/build.ts

@@ -1,8 +0,0 @@
-import { log, runCommand } from '@stacksjs/cli'
-
-const result = await runCommand('bun build ./src/index.ts --outdir dist --format esm --external @stacksjs/cli --external @stacksjs/path --external @stacksjs/storage --target node', {
-  cwd: import.meta.dir,
-})
-
-if (result.isErr())
-  log.error(result.error)

package/core/error-handling/dist/index.js

@@ -1,432 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getProtoOf = Object.getPrototypeOf;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
-// ../../../../node_modules/neverthrow/dist/index.cjs.js
-var require_index_cjs = __commonJS((exports) => {
-  var __awaiter = function(thisArg, _arguments, P, generator) {
-    function adopt(value) {
-      return value instanceof P ? value : new P(function(resolve) {
-        resolve(value);
-      });
-    }
-    return new (P || (P = Promise))(function(resolve, reject) {
-      function fulfilled(value) {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function rejected(value) {
-        try {
-          step(generator["throw"](value));
-        } catch (e) {
-          reject(e);
-        }
-      }
-      function step(result) {
-        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
-      }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-  };
-  var __values = function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m)
-      return m.call(o);
-    if (o && typeof o.length === "number")
-      return {
-        next: function() {
-          if (o && i >= o.length)
-            o = undefined;
-          return { value: o && o[i++], done: !o };
-        }
-      };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-  };
-  var __await = function(v) {
-    return this instanceof __await ? (this.v = v, this) : new __await(v);
-  };
-  var __asyncGenerator = function(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator)
-      throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-      return this;
-    }, i;
-    function verb(n) {
-      if (g[n])
-        i[n] = function(v) {
-          return new Promise(function(a, b) {
-            q.push([n, v, a, b]) > 1 || resume(n, v);
-          });
-        };
-    }
-    function resume(n, v) {
-      try {
-        step(g[n](v));
-      } catch (e) {
-        settle(q[0][3], e);
-      }
-    }
-    function step(r) {
-      r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
-    }
-    function fulfill(value) {
-      resume("next", value);
-    }
-    function reject(value) {
-      resume("throw", value);
-    }
-    function settle(f, v) {
-      if (f(v), q.shift(), q.length)
-        resume(q[0][0], q[0][1]);
-    }
-  };
-  var __asyncDelegator = function(o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function(e) {
-      throw e;
-    }), verb("return"), i[Symbol.iterator] = function() {
-      return this;
-    }, i;
-    function verb(n, f) {
-      i[n] = o[n] ? function(v) {
-        return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
-      } : f;
-    }
-  };
-  var __asyncValues = function(o) {
-    if (!Symbol.asyncIterator)
-      throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
-      return this;
-    }, i);
-    function verb(n) {
-      i[n] = o[n] && function(v) {
-        return new Promise(function(resolve, reject) {
-          v = o[n](v), settle(resolve, reject, v.done, v.value);
-        });
-      };
-    }
-    function settle(resolve, reject, d, v) {
-      Promise.resolve(v).then(function(v2) {
-        resolve({ value: v2, done: d });
-      }, reject);
-    }
-  };
-  var safeTry = function(body) {
-    const n = body().next();
-    if (n instanceof Promise) {
-      return n.then((r) => r.value);
-    }
-    return n.value;
-  };
-  Object.defineProperty(exports, "__esModule", { value: true });
-  var defaultErrorConfig = {
-    withStackTrace: false
-  };
-  var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
-    const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
-    const maybeStack = config.withStackTrace ? new Error().stack : undefined;
-    return {
-      data,
-      message,
-      stack: maybeStack
-    };
-  };
-
-  class ResultAsync {
-    constructor(res) {
-      this._promise = res;
-    }
-    static fromSafePromise(promise) {
-      const newPromise = promise.then((value) => new Ok(value));
-      return new ResultAsync(newPromise);
-    }
-    static fromPromise(promise, errorFn) {
-      const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
-      return new ResultAsync(newPromise);
-    }
-    static combine(asyncResultList) {
-      return combineResultAsyncList(asyncResultList);
-    }
-    static combineWithAllErrors(asyncResultList) {
-      return combineResultAsyncListWithAllErrors(asyncResultList);
-    }
-    map(f) {
-      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
-        if (res.isErr()) {
-          return new Err(res.error);
-        }
-        return new Ok(yield f(res.value));
-      })));
-    }
-    mapErr(f) {
-      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
-        if (res.isOk()) {
-          return new Ok(res.value);
-        }
-        return new Err(yield f(res.error));
-      })));
-    }
-    andThen(f) {
-      return new ResultAsync(this._promise.then((res) => {
-        if (res.isErr()) {
-          return new Err(res.error);
-        }
-        const newValue = f(res.value);
-        return newValue instanceof ResultAsync ? newValue._promise : newValue;
-      }));
-    }
-    orElse(f) {
-      return new ResultAsync(this._promise.then((res) => __awaiter(this, undefined, undefined, function* () {
-        if (res.isErr()) {
-          return f(res.error);
-        }
-        return new Ok(res.value);
-      })));
-    }
-    match(ok2, _err) {
-      return this._promise.then((res) => res.match(ok2, _err));
-    }
-    unwrapOr(t) {
-      return this._promise.then((res) => res.unwrapOr(t));
-    }
-    safeUnwrap() {
-      return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
-        return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
-      });
-    }
-    then(successCallback, failureCallback) {
-      return this._promise.then(successCallback, failureCallback);
-    }
-  }
-  var okAsync = (value) => new ResultAsync(Promise.resolve(new Ok(value)));
-  var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
-  var fromPromise = ResultAsync.fromPromise;
-  var fromSafePromise = ResultAsync.fromSafePromise;
-  var appendValueToEndOfList = (value) => (list) => [...list, value];
-  var combineResultList = (resultList) => resultList.reduce((acc, result) => acc.isOk() ? result.isErr() ? err(result.error) : acc.map(appendValueToEndOfList(result.value)) : acc, ok([]));
-  var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
-  var combineResultListWithAllErrors = (resultList) => resultList.reduce((acc, result) => result.isErr() ? acc.isErr() ? err([...acc.error, result.error]) : err([result.error]) : acc.isErr() ? acc : ok([...acc.value, result.value]), ok([]));
-  var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
-  exports.Result = undefined;
-  (function(Result) {
-    function fromThrowable2(fn, errorFn) {
-      return (...args) => {
-        try {
-          const result = fn(...args);
-          return ok(result);
-        } catch (e) {
-          return err(errorFn ? errorFn(e) : e);
-        }
-      };
-    }
-    Result.fromThrowable = fromThrowable2;
-    function combine(resultList) {
-      return combineResultList(resultList);
-    }
-    Result.combine = combine;
-    function combineWithAllErrors(resultList) {
-      return combineResultListWithAllErrors(resultList);
-    }
-    Result.combineWithAllErrors = combineWithAllErrors;
-  })(exports.Result || (exports.Result = {}));
-  var ok = (value) => new Ok(value);
-  var err = (err2) => new Err(err2);
-
-  class Ok {
-    constructor(value) {
-      this.value = value;
-    }
-    isOk() {
-      return true;
-    }
-    isErr() {
-      return !this.isOk();
-    }
-    map(f) {
-      return ok(f(this.value));
-    }
-    mapErr(_f) {
-      return ok(this.value);
-    }
-    andThen(f) {
-      return f(this.value);
-    }
-    orElse(_f) {
-      return ok(this.value);
-    }
-    asyncAndThen(f) {
-      return f(this.value);
-    }
-    asyncMap(f) {
-      return ResultAsync.fromSafePromise(f(this.value));
-    }
-    unwrapOr(_v) {
-      return this.value;
-    }
-    match(ok2, _err) {
-      return ok2(this.value);
-    }
-    safeUnwrap() {
-      const value = this.value;
-      return function* () {
-        return value;
-      }();
-    }
-    _unsafeUnwrap(_) {
-      return this.value;
-    }
-    _unsafeUnwrapErr(config) {
-      throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
-    }
-  }
-
-  class Err {
-    constructor(error) {
-      this.error = error;
-    }
-    isOk() {
-      return false;
-    }
-    isErr() {
-      return !this.isOk();
-    }
-    map(_f) {
-      return err(this.error);
-    }
-    mapErr(f) {
-      return err(f(this.error));
-    }
-    andThen(_f) {
-      return err(this.error);
-    }
-    orElse(f) {
-      return f(this.error);
-    }
-    asyncAndThen(_f) {
-      return errAsync(this.error);
-    }
-    asyncMap(_f) {
-      return errAsync(this.error);
-    }
-    unwrapOr(v) {
-      return v;
-    }
-    match(_ok, err2) {
-      return err2(this.error);
-    }
-    safeUnwrap() {
-      const error = this.error;
-      return function* () {
-        yield err(error);
-        throw new Error("Do not use this generator out of `safeTry`");
-      }();
-    }
-    _unsafeUnwrap(config) {
-      throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
-    }
-    _unsafeUnwrapErr(_) {
-      return this.error;
-    }
-  }
-  var fromThrowable = exports.Result.fromThrowable;
-  exports.Err = Err;
-  exports.Ok = Ok;
-  exports.ResultAsync = ResultAsync;
-  exports.err = err;
-  exports.errAsync = errAsync;
-  exports.fromPromise = fromPromise;
-  exports.fromSafePromise = fromSafePromise;
-  exports.fromThrowable = fromThrowable;
-  exports.ok = ok;
-  exports.okAsync = okAsync;
-  exports.safeTry = safeTry;
-});
-
-// src/handler.ts
-import {logsPath} from "@stacksjs/path";
-function handleError(err, options) {
-  return ErrorHandler.handle(err, options);
-}
-var StacksError = Error;
-
-class ErrorHandler {
-  static logFile = logsPath("errors.log");
-  static handle(err, options) {
-    if (!(options instanceof Error) && options?.silent !== false)
-      this.writeErrorToConsole(err, options);
-    if (typeof err === "string")
-      err = new StacksError(err);
-    this.writeErrorToFile(err).catch((e) => console.error(e));
-    return err;
-  }
-  static handleError(err, options) {
-    this.handle(err, options);
-    return err;
-  }
-  static async writeErrorToFile(err) {
-    const formattedError = `[${new Date().toISOString()}] ${err.name}: ${err.message}\n`;
-    const file = Bun.file(this.logFile);
-    const writer = file.writer();
-    const text = await file.text();
-    writer.write(`${text}\n`);
-    writer.write(`${formattedError}\n`);
-    await writer.end();
-  }
-  static writeErrorToConsole(err, options) {
-    if (options)
-      console.error(err, options);
-    else
-      console.error(err);
-  }
-}
-
-// src/index.ts
-var import_neverthrow = __toESM(require_index_cjs(), 1);
-var export_okAsync = import_neverthrow.okAsync;
-var export_ok = import_neverthrow.ok;
-var export_fromThrowable = import_neverthrow.fromThrowable;
-var export_fromSafePromise = import_neverthrow.fromSafePromise;
-var export_fromPromise = import_neverthrow.fromPromise;
-var export_errAsync = import_neverthrow.errAsync;
-var export_err = import_neverthrow.err;
-var export_ResultAsync = import_neverthrow.ResultAsync;
-var export_Result = import_neverthrow.Result;
-var export_Ok = import_neverthrow.Ok;
-var export_Err = import_neverthrow.Err;
-
-export {
-  export_okAsync as okAsync,
-  export_ok as ok,
-  handleError,
-  export_fromThrowable as fromThrowable,
-  export_fromSafePromise as fromSafePromise,
-  export_fromPromise as fromPromise,
-  export_errAsync as errAsync,
-  export_err as err,
-  StacksError,
-  export_ResultAsync as ResultAsync,
-  export_Result as Result,
-  export_Ok as Ok,
-  ErrorHandler,
-  export_Err as Err
-};

package/core/error-handling/package.json

@@ -1,63 +0,0 @@
-{
-  "name": "@stacksjs/error-handling",
-  "type": "module",
-  "version": "0.58.73",
-  "description": "Type safe error handling.",
-  "author": "Chris Breuer",
-  "license": "MIT",
-  "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/error-handling#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./storage/framework/core/error-handling"
-  },
-  "bugs": {
-    "url": "https://github.com/stacksjs/stacks/issues"
-  },
-  "keywords": [
-    "errors",
-    "error-handling",
-    "neverthrow",
-    "type safe",
-    "stacks"
-  ],
-  "exports": {
-    ".": {
-      "bun": "./src/index.ts",
-      "import": "./dist/index.js"
-    },
-    "./*": {
-      "bun": "./*"
-    }
-  },
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
-    "prepublishOnly": "bun --bun run build"
-  },
-  "peerDependencies": {
-    "@stacksjs/cli": "workspace:*",
-    "@stacksjs/path": "workspace:*",
-    "@stacksjs/types": "workspace:*"
-  },
-  "dependencies": {
-    "@stacksjs/cli": "workspace:*",
-    "@stacksjs/path": "workspace:*",
-    "@stacksjs/types": "workspace:*",
-    "neverthrow": "^6.1.0"
-  },
-  "devDependencies": {
-    "@stacksjs/development": "workspace:*"
-  }
-}

package/core/error-handling/src/handler.ts

@@ -1,51 +0,0 @@
-import { logsPath } from '@stacksjs/path'
-
-interface ErrorOptions {
-  silent?: boolean
-}
-
-export const StacksError = Error
-
-export class ErrorHandler {
-  static logFile = logsPath('errors.log')
-
-  static handle(err: ErrorDescription | Error, options?: ErrorOptions | Error) {
-    // let's only write to the console if we are not in silent mode
-    if (!(options instanceof Error) && options?.silent !== false)
-      this.writeErrorToConsole(err, options)
-
-    if (typeof err === 'string')
-      err = new StacksError(err)
-
-    this.writeErrorToFile(err).catch(e => console.error(e))
-
-    return err
-  }
-
-  static handleError(err: Error, options?: ErrorOptions) {
-    this.handle(err, options)
-    return err
-  }
-
-  static async writeErrorToFile(err: Error) {
-    const formattedError = `[${new Date().toISOString()}] ${err.name}: ${err.message}\n`
-    const file = Bun.file(this.logFile)
-    const writer = file.writer()
-    const text = await file.text()
-    writer.write(`${text}\n`)
-    writer.write(`${formattedError}\n`)
-    await writer.end()
-  }
-
-  static writeErrorToConsole(err: string | Error, options?: ErrorOptions) {
-    if (options)
-      console.error(err, options)
-    else
-      console.error(err)
-  }
-}
-
-type ErrorDescription = string
-export function handleError(err: ErrorDescription | Error, options?: ErrorOptions | Error): Error {
-  return ErrorHandler.handle(err, options)
-}

package/core/error-handling/src/index.ts

@@ -1,2 +0,0 @@
-export * from './handler'
-export { err, errAsync, fromPromise, fromSafePromise, fromThrowable, ok, okAsync, Err, Ok, Result, ResultAsync } from 'neverthrow'

package/core/error-handling/tests/example.test.ts

@@ -1,5 +0,0 @@
-describe('example test', () => {
-  it('assert', () => {
-    expect(1).toBe(1)
-  })
-})

package/core/error-handling/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../tsconfig.json"
-}

package/core/eslint-config/.gitattributes

@@ -1,2 +0,0 @@
-* text=auto
-*.* text eol=lf