stacks 0.56.24 → 0.58.18

package/core/src/env/src/index.ts

@@ -0,0 +1,76 @@
+import p from 'node:process'
+import fs from 'fs-extra'
+import { projectPath } from '@stacksjs/path'
+import { ValidationBoolean, ValidationEnum, ValidationNumber } from '@stacksjs/validation'
+import type { EnvKey } from '../../../../stack/env'
+import type { Env } from './types'
+
+// interface EnumObject {
+//   [key: string]: string[]
+// }
+
+// export const enums: EnumObject = {
+//   APP_ENV: ['local', 'dev', 'development', 'staging', 'prod', 'production'],
+//   DB_CONNECTION: ['mysql', 'sqlite', 'postgres', 'planetscale'],
+//   MAIL_MAILER: ['smtp', 'mailgun', 'ses', 'postmark', 'sendmail', 'log'],
+//   SEARCH_ENGINE_DRIVER: ['meilisearch', 'algolia', 'typesense'],
+//   FRONTEND_APP_ENV: ['development', 'staging', 'production'],
+// }
+
+const handler = {
+  get: (target: Env, key: EnvKey) => {
+    const value = target[key] as any
+
+    // if value is a string but only contains numbers, and the key is not AWS_ACCOUNT_ID, return it as a number
+    if (typeof value === 'string' && /^\d+$/.test(value) && key !== 'AWS_ACCOUNT_ID')
+      return Number(value)
+
+    // if value is a string but only contains boolean values, return it as a boolean
+    if (typeof value === 'string' && /^(true|false)$/.test(value))
+      return value === 'true'
+
+    // at some point, let's see if we can remove the need for below
+    if (value instanceof ValidationEnum)
+      return target[key] as string
+
+    if (value instanceof ValidationBoolean)
+      return !!target[key]
+
+    if (value instanceof ValidationNumber)
+      return Number(target[key])
+
+    return value as string
+  },
+}
+
+export function process() {
+  return typeof Bun !== 'undefined'
+    ? Bun.env
+    : p.env as unknown as Env
+}
+
+export const env: Env = new Proxy(process(), handler)
+
+export function writeEnv(key: EnvKey, value: string, options?: { path: string }) {
+  const envPath = options?.path || projectPath('.env')
+  const env = fs.readFileSync(envPath, 'utf-8')
+
+  // Split the file into lines
+  const lines = env.split('\n')
+
+  // Find the line with the variable we want to update
+  const index = lines.findIndex(line => line.startsWith(`${key}=`))
+
+  // If the variable exists, update it
+  if (index !== -1)
+    lines[index] = `${key}=${value}`
+
+  // Otherwise, add a new line
+  else
+    lines.push(`${key}=${value}`)
+
+  // Join the lines back into a string and write it to the .env file
+  fs.writeFileSync(envPath, lines.join('\n'))
+}
+
+export * from './types'

package/core/src/env/src/types.ts

@@ -0,0 +1,54 @@
+import type { Infer, VineBoolean, VineEnum, VineNumber, VineString } from '@stacksjs/validation'
+import { validator } from '@stacksjs/validation'
+import env from '../../../../../../config/env'
+import type { EnvKey } from '../../../../stack/env'
+
+// import type { Validate } from '@stacksjs/validation'
+
+// we need to get this just into right format so we can infer the type
+type EnvValue = string | boolean | number | readonly string[]
+type EnvType = typeof env
+type EnvKeys = keyof EnvType
+type EnvMap = { [K in EnvKeys]: EnvType[K] extends string ? VineString :
+  EnvType[K] extends number ? VineNumber :
+    EnvType[K] extends boolean ? VineBoolean :
+      EnvType[K] extends readonly string[] ? VineEnum<string[]> : unknown }
+
+type ValidatorType = VineString | VineNumber | VineBoolean | VineEnum<string[]>
+
+const envStructure = Object.entries(env).reduce((acc, [key, value]) => {
+  let validatorType: ValidatorType
+  switch (typeof value) {
+    case 'string':
+      validatorType = validator.string()
+      break
+    case 'number':
+      validatorType = validator.number()
+      break
+    case 'boolean':
+      validatorType = validator.boolean()
+      break
+    default:
+      if (Array.isArray(value)) {
+        validatorType = validator.enum(value as string[])
+        break
+      }
+      throw new Error(`Invalid env value for ${key}`)
+  }
+  const envKey = key as EnvKeys
+
+  acc[envKey] = validatorType as any
+  return acc
+}, {} as EnvMap)
+
+export const envSchema = validator.object(envStructure)
+export type Env = Infer<typeof envSchema>
+
+export type EnvOptions = Env
+export type EnvConfig = Partial<Record<EnvKey, EnvValue>>
+
+export interface FrontendEnv {
+  FRONTEND_APP_ENV: 'local' | 'development' | 'staging' | 'production'
+  FRONTEND_APP_URL: string
+}
+export type FrontendEnvKeys = keyof FrontendEnv

package/core/src/env/tests/example.test.ts

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

package/core/src/error-handling/README.md

@@ -0,0 +1,131 @@
+# 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/src/error-handling/build.ts

@@ -0,0 +1,8 @@
+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/src/error-handling/dist/index.js

@@ -0,0 +1,432 @@
+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);
+
+// /Users/chrisbreuer/Code/stacks/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
+};