catalyst-core-internal 0.0.1-beta.0

package/README.md

@@ -0,0 +1,145 @@
+# Catalyst
+
+Frontend framework with server rendering support for web applications.
+
+## Table of Contents 
+
+- Overview
+- Installation
+- Data Fetching with Catalyst
+    - serverFetcher
+    - clientFetcher
+    - refetch (for data revalidation)
+- State Management
+
+## Overview 
+
+This package provides a way to proxy your request through your server. It allows you to cache your incoming request to improve your server response time.
+
+
+## Installation
+
+**System Requirements**
+
+- Node version 20.4.0 or later
+- macOS and Linux are supported
+
+
+**Automatic Installation**
+
+- Run the following commands in the directory where you want to set up the Catalyst app.
+
+```js
+npx create-catalyst-app@latest
+```
+
+If successful, you will see the following prompts in your terminal.
+
+- Enter the name of your Catalyst application.
+- Choose state management.
+- Once packages are installed, start the development server by running the following command.
+
+```js
+npm run start
+```
+
+- Navigate to http://localhost:3005
+
+The dev server should be running now.
+
+Visit our official documentation: 
+https://catalyst.1mg.com/public_docs/content/installation
+
+
+
+## Data Fetching with Catalyst 
+
+we have serverFetcher function for fetching with SSR and clientFetcher function for fetching during client side rendering and navigations.
+
+**serverFetcher**
+
+server fetcher will get request, request params, search params and store (if project is setup with redux or rtk) as arguments. We can declare it as an async function and use await for fetching or use then chaining for data fetching.
+
+if server fetcher is called for a route then client fetcher will not be called for that route, unless called with refetch.
+```js
+Home.serverFetcher = async ({ req,params,searchParams }, { store }) => {
+  store.dispatch(someAction())
+  const res = await fetch("some_url");
+  const json = await res.json();
+  return json;
+};
+```
+data returned from fetcher function will be accessible through useCurrentRouteData() hook provided by router.
+```js
+const [data,error,isFetched] = useCurrentRouteData()
+```
+error and loading state would be handled by router.
+
+**clientFetcher**
+
+client fetcher would be called on client side rendering and client side navigations. `store` would be available as a param in client side for dispatching redux/rtk actions.
+
+```js
+Home.clientFetcher = async ({route,location,params,searchParams,navigate},{store}) => {
+  store.dispatch(someAction())
+  const res = await fetch("some_url");
+  const json = await res.json();
+  return json;
+};
+```
+data returned from client fetcher function will be accessible through  useCurrentRouteData() hook provided by router (hook for data access through client is same).
+```js
+const [data,error,isFetched] = useCurrentRouteData()
+```
+
+
+**refetch (for data revalidation)**
+
+refetch function can be used were we need to execute clientFetcher based on some condition(such as for infinite scroll or some state change inside container or onClick.)
+
+We can pass arguments in refetch function which would 
+
+```js
+const [data,error,isFetched,refetch] = useCurrentRouteData()
+
+useEffect(()=>{
+  refetch({refetchArgument:some_value})
+},[arg])
+
+clientFetcher = ({},{refetchArgument}) => {
+ 
+  const res = await api_call // refetchArg can be used as a param in api call
+  return res
+}
+
+```
+
+
+## State Management
+state management wrappers are defined in stateProvider.js file
+
+store can be configured by manipulating store/index.js as per user requirements (custom middlewares etc can be added in this way.
+
+initial state and request object would be provided in createStore function which will be called on server and client, we use the params to add additional arguments and middlewares in redux store. 
+
+```js
+const configureStore = (initialState, cookies, requestObj, customHeaders) => {
+    const api = fetchInstance
+    const store = createStore({
+        reducer: rootReducer,
+        middleware: (getDefaultMiddleware) =>
+            getDefaultMiddleware({
+                thunk: {
+                    extraArgument: { api },
+                },
+            }),
+        preloadedState: initialState,
+    })
+    return store
+}
+
+export default configureStore
+```
+
+## Documentation
+Visit https://catalyst.1mg.com to view the full documentation.

package/babel.config.json

@@ -0,0 +1,24 @@
+{
+    "presets": [
+        [
+            "@babel/preset-env",
+            {
+                "targets": {
+                    "node": "current"
+                }
+            }
+        ],
+        "@babel/preset-react"
+    ],
+    "plugins": [
+        "@babel/plugin-proposal-object-rest-spread",
+        "transform-class-properties",
+        "@loadable/babel-plugin"
+    ],
+    "env": {
+        "test": {
+            "presets": ["@babel/preset-react"]
+        }
+    },
+    "ignore": ["__TEST__"]
+}

package/bin/catalyst.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+'use strict';
+process.on('unhandledRejection', err => {
+    throw err;
+});
+const { spawnSync } = require('node:child_process');
+const args = process.argv.slice(2);
+const scriptIndex = args.findIndex(
+  x => x === 'build' || x === 'start' || x=== 'serve'
+);
+const script = scriptIndex === -1 ? args[0] : args[scriptIndex];
+const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : [];
+if (['build', 'start', 'serve'].includes(script)) {
+  const result = spawnSync(
+    process.execPath,
+    nodeArgs
+      .concat(require.resolve('../scripts/' + script))
+      .concat(args.slice(scriptIndex + 1)),
+    { stdio: 'inherit' }
+  );
+  if (result.signal) {
+    if (result.signal === 'SIGKILL') {
+      console.log(
+        'The build failed because the process exited too early. ' +
+          'This probably means the system ran out of memory or someone called ' +
+          '`kill -9` on the process.'
+      );
+    } else if (result.signal === 'SIGTERM') {
+      console.log(
+        'The build failed because the process exited too early. ' +
+          'Someone might have called `kill` or `killall`, or the system could ' +
+          'be shutting down.'
+      );
+    }
+    process.exit(1);
+  }
+  process.exit(result.status);
+} else {
+  console.log('Unknown script "' + script + '".');
+}

package/caching.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _apiCaching = require("@tata1mg/api-caching");
+Object.keys(_apiCaching).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _apiCaching[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _apiCaching[key];
+    }
+  });
+});

package/config.json

@@ -0,0 +1,7 @@
+{
+    "cssModulesIdentifierDev": "[name]__[local]",
+    "cssModulesIdentifierProd": "[name]__[local]__[hash:base64:5]",
+    "chunkFileNameDev": "[name].bundle.js",
+    "chunkFileNameProd": "[name].[contenthash].js",
+    "cssChunkFileName": "[name].[contenthash].css"
+}

package/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _index = require("./server/renderer/document/index");
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _index[key];
+    }
+  });
+});

package/logger.js

@@ -0,0 +1,96 @@
+"use strict";
+
+const winston = require("winston");
+const DailyRotateFile = require("winston-daily-rotate-file");
+const pc = require("picocolors");
+const {
+  createLogger,
+  format,
+  transports
+} = winston;
+
+/**
+ * @description Logger library with rotational strategy. Creates a logs folder in root.
+ *              With debug, error and info log directories with their respective log files.
+ *
+ * @format Logstash with timestamp
+ * @param config { @enableDebugLogs: Bool // default: true }
+ * @returns loggerInstance
+ *
+ */
+const configureLogger = (config = {}) => {
+  const {
+    enableDebugLogs = true,
+    enableFileLogging = true,
+    enableConsoleLogging = true
+  } = config;
+  const consoleTransport = new transports.Console({
+    level: "debug"
+  });
+  const fileTransport = (type = "info") => {
+    return new DailyRotateFile({
+      filename: `./logs/${type}/%DATE%.${type}.log`,
+      datePattern: "YYYY-MM-DD",
+      maxFiles: "3d",
+      // Logs will be removed after 2days,
+      loglevel: type,
+      level: type
+    });
+  };
+  const infoLogger = createLogger({
+    format: format.combine(format.timestamp({
+      format: "YYYY-MM-DD HH:mm:ss"
+    }), format.json()),
+    defaultMeta: {
+      loglevel: "info"
+    }
+  });
+  const debugLogger = createLogger({
+    format: format.combine(format.timestamp({
+      format: "YYYY-MM-DD HH:mm:ss"
+    }), format.json()),
+    defaultMeta: {
+      loglevel: "debug"
+    }
+  });
+  const errorLogger = createLogger({
+    format: format.combine(format.timestamp({
+      format: "YYYY-MM-DD HH:mm:ss"
+    }), format.json()),
+    defaultMeta: {
+      loglevel: "error"
+    }
+  });
+  if (enableConsoleLogging && JSON.parse(enableConsoleLogging)) {
+    infoLogger.add(consoleTransport);
+    debugLogger.add(consoleTransport);
+    errorLogger.add(consoleTransport);
+  }
+  if (enableFileLogging && JSON.parse(enableFileLogging)) {
+    infoLogger.add(fileTransport("info"));
+    debugLogger.add(fileTransport("debug"));
+    errorLogger.add(fileTransport("error"));
+  }
+  const Logger = {
+    debug: () => {},
+    error: msg => {
+      console.log(pc.red(pc.bold("ERROR: " + JSON.stringify(msg))));
+      errorLogger.error(msg);
+    },
+    info: msg => {
+      console.log(pc.green(pc.bold("INFO: " + JSON.stringify(msg))));
+      infoLogger.info(msg);
+    }
+  };
+  if (enableDebugLogs && JSON.parse(enableDebugLogs)) {
+    Logger.debug = msg => {
+      console.log(pc.yellow(pc.bold("DEBUG: " + JSON.stringify(msg))));
+      debugLogger.debug(msg);
+    };
+  }
+  if (global) global.logger = Logger;
+  return Logger;
+};
+module.exports = {
+  configureLogger
+};

package/package.json

@@ -0,0 +1,84 @@
+{
+   "name": "catalyst-core-internal",
+   "version": "0.0.1-beta.0",
+   "main": "index.js",
+   "description": "Web framework that provides great performance out of the box",
+   "bin": {
+      "catalyst": "./bin/catalyst.js"
+   },
+   "scripts": {
+      "prepare": "babel src --out-dir . ",
+      "start": "node ./scripts/checkVersion && npm run start:client & npm run start:server --disable-warning=ExperimentalWarning",
+      "start:client": "npx babel-node -r ./scripts/loadScriptsBeforeServerStarts.js webpack/development.client.babel --disable-warning=ExperimentalWarning",
+      "start:server": "npx babel-node -r ./scripts/loadScriptsBeforeServerStarts.js ./server/startServer.js --watch-path=${npm_config_src_path}/server --watch-path=${npm_config_src_path}/src --ignore='__IGNORE__' --disable-warning=ExperimentalWarning",
+      "build": "node ./scripts/checkVersion && npm run build:prepare && npm run build:client && npm run build:ssr && npm run build:server --disable-warning=ExperimentalWarning",
+      "build:prepare": "rm -rf ${npm_config_src_path}/build & node ./scripts/loadScriptsBeforeServerStarts.js",
+      "build:client": "APPLICATION=${npm_config_app_name} NODE_ENV=production  webpack --config ./webpack/production.client.babel.js --progress",
+      "build:ssr": "APPLICATION=${npm_config_app_name} NODE_ENV=production SSR=true webpack --config ./webpack/production.ssr.babel.js --progress",
+      "build:server": "APPLICATION=${npm_config_app_name} NODE_ENV=production npx babel ./server --out-dir ${npm_config_src_path}/build --ignore '**/*.test.js,./server/renderer/handler.js' && APPLICATION=${npm_config_app_name} npx babel ${npm_config_src_path}/server --out-dir ${npm_config_src_path}/build ",
+      "serve": "APPLICATION=${npm_config_app_name} NODE_ENV=production node -r ./scripts/loadScriptsBeforeServerStarts.js ${npm_config_src_path}/build/startServer.js --disable-warning=ExperimentalWarning"
+   },
+   "license": "ISC",
+   "dependencies": {
+      "@babel/cli": "^7.23.0",
+      "@babel/core": "^7.23.2",
+      "@babel/node": "^7.22.19",
+      "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
+      "@babel/plugin-transform-react-jsx": "^7.22.15",
+      "@babel/preset-env": "^7.23.2",
+      "@babel/preset-react": "^7.22.15",
+      "@babel/register": "^7.22.15",
+      "@loadable/babel-plugin": "^5.16.1",
+      "@loadable/component": "^5.15.3",
+      "@loadable/server": "^5.16.1",
+      "@loadable/webpack-plugin": "^5.15.2",
+      "@pmmmwh/react-refresh-webpack-plugin": "^0.5.11",
+      "@svgr/webpack": "^8.1.0",
+      "@tata1mg/router": "^0.0.1-alpha.13",
+      "app-root-path": "^3.1.0",
+      "babel-loader": "^9.1.3",
+      "babel-plugin-dynamic-import-node": "^2.3.3",
+      "babel-plugin-syntax-dynamic-import": "^6.18.0",
+      "babel-plugin-transform-class-properties": "^6.24.1",
+      "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
+      "babel-plugin-transform-export-extensions": "^6.22.0",
+      "babel-plugin-transform-react-remove-prop-types": "^0.4.24",
+      "body-parser": "^1.20.2",
+      "chokidar": "^3.6.0",
+      "compression": "^1.7.4",
+      "cookie-parser": "^1.4.6",
+      "css-hot-loader": "^1.4.4",
+      "css-loader": "^6.8.1",
+      "css-modules-require-hook": "^4.2.3",
+      "express": "^4.18.2",
+      "express-static-gzip": "^2.1.7",
+      "file-loader": "^6.2.0",
+      "html-loader": "^4.2.0",
+      "img-loader": "^4.0.0",
+      "isomorphic-dompurify": "^1.13.0",
+      "mini-css-extract-plugin": "^2.7.6",
+      "module-alias": "^2.2.3",
+      "picocolors": "^1.0.0",
+      "postcss-loader": "^7.3.3",
+      "react": "^18.2.0",
+      "react-dom": "^18.2.0",
+      "react-redux": "^8.1.3",
+      "react-refresh": "^0.14.0",
+      "react-router-dom": "^6.16.0",
+      "redux": "^4.2.1",
+      "sass": "^1.69.5",
+      "sass-loader": "^13.3.2",
+      "sass-resources-loader": "^2.2.5",
+      "ua-parser-js": "^1.0.37",
+      "url": "^0.11.3",
+      "url-loader": "^4.1.1",
+      "webpack": "^5.88.2",
+      "webpack-bundle-analyzer": "^4.9.1",
+      "webpack-cli": "^5.1.4",
+      "webpack-dev-server": "^4.15.1",
+      "webpack-merge": "^5.9.0",
+      "webpack-node-externals": "^3.0.0",
+      "winston": "^3.11.0",
+      "winston-daily-rotate-file": "^5.0.0"
+   }
+}

package/packages/create-framework-app/templates/redux-js/node_modules/@babel/core/lib/config/caching.js

@@ -0,0 +1,261 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertSimpleType = assertSimpleType;
+exports.makeStrongCache = makeStrongCache;
+exports.makeStrongCacheSync = makeStrongCacheSync;
+exports.makeWeakCache = makeWeakCache;
+exports.makeWeakCacheSync = makeWeakCacheSync;
+function _gensync() {
+  const data = require("gensync");
+  _gensync = function () {
+    return data;
+  };
+  return data;
+}
+var _async = require("../gensync-utils/async.js");
+var _util = require("./util.js");
+const synchronize = gen => {
+  return _gensync()(gen).sync;
+};
+function* genTrue() {
+  return true;
+}
+function makeWeakCache(handler) {
+  return makeCachedFunction(WeakMap, handler);
+}
+function makeWeakCacheSync(handler) {
+  return synchronize(makeWeakCache(handler));
+}
+function makeStrongCache(handler) {
+  return makeCachedFunction(Map, handler);
+}
+function makeStrongCacheSync(handler) {
+  return synchronize(makeStrongCache(handler));
+}
+function makeCachedFunction(CallCache, handler) {
+  const callCacheSync = new CallCache();
+  const callCacheAsync = new CallCache();
+  const futureCache = new CallCache();
+  return function* cachedFunction(arg, data) {
+    const asyncContext = yield* (0, _async.isAsync)();
+    const callCache = asyncContext ? callCacheAsync : callCacheSync;
+    const cached = yield* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data);
+    if (cached.valid) return cached.value;
+    const cache = new CacheConfigurator(data);
+    const handlerResult = handler(arg, cache);
+    let finishLock;
+    let value;
+    if ((0, _util.isIterableIterator)(handlerResult)) {
+      value = yield* (0, _async.onFirstPause)(handlerResult, () => {
+        finishLock = setupAsyncLocks(cache, futureCache, arg);
+      });
+    } else {
+      value = handlerResult;
+    }
+    updateFunctionCache(callCache, cache, arg, value);
+    if (finishLock) {
+      futureCache.delete(arg);
+      finishLock.release(value);
+    }
+    return value;
+  };
+}
+function* getCachedValue(cache, arg, data) {
+  const cachedValue = cache.get(arg);
+  if (cachedValue) {
+    for (const {
+      value,
+      valid
+    } of cachedValue) {
+      if (yield* valid(data)) return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function* getCachedValueOrWait(asyncContext, callCache, futureCache, arg, data) {
+  const cached = yield* getCachedValue(callCache, arg, data);
+  if (cached.valid) {
+    return cached;
+  }
+  if (asyncContext) {
+    const cached = yield* getCachedValue(futureCache, arg, data);
+    if (cached.valid) {
+      const value = yield* (0, _async.waitFor)(cached.value.promise);
+      return {
+        valid: true,
+        value
+      };
+    }
+  }
+  return {
+    valid: false,
+    value: null
+  };
+}
+function setupAsyncLocks(config, futureCache, arg) {
+  const finishLock = new Lock();
+  updateFunctionCache(futureCache, config, arg, finishLock);
+  return finishLock;
+}
+function updateFunctionCache(cache, config, arg, value) {
+  if (!config.configured()) config.forever();
+  let cachedValue = cache.get(arg);
+  config.deactivate();
+  switch (config.mode()) {
+    case "forever":
+      cachedValue = [{
+        value,
+        valid: genTrue
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "invalidate":
+      cachedValue = [{
+        value,
+        valid: config.validator()
+      }];
+      cache.set(arg, cachedValue);
+      break;
+    case "valid":
+      if (cachedValue) {
+        cachedValue.push({
+          value,
+          valid: config.validator()
+        });
+      } else {
+        cachedValue = [{
+          value,
+          valid: config.validator()
+        }];
+        cache.set(arg, cachedValue);
+      }
+  }
+}
+class CacheConfigurator {
+  constructor(data) {
+    this._active = true;
+    this._never = false;
+    this._forever = false;
+    this._invalidate = false;
+    this._configured = false;
+    this._pairs = [];
+    this._data = void 0;
+    this._data = data;
+  }
+  simple() {
+    return makeSimpleConfigurator(this);
+  }
+  mode() {
+    if (this._never) return "never";
+    if (this._forever) return "forever";
+    if (this._invalidate) return "invalidate";
+    return "valid";
+  }
+  forever() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never) {
+      throw new Error("Caching has already been configured with .never()");
+    }
+    this._forever = true;
+    this._configured = true;
+  }
+  never() {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._forever) {
+      throw new Error("Caching has already been configured with .forever()");
+    }
+    this._never = true;
+    this._configured = true;
+  }
+  using(handler) {
+    if (!this._active) {
+      throw new Error("Cannot change caching after evaluation has completed.");
+    }
+    if (this._never || this._forever) {
+      throw new Error("Caching has already been configured with .never or .forever()");
+    }
+    this._configured = true;
+    const key = handler(this._data);
+    const fn = (0, _async.maybeAsync)(handler, `You appear to be using an async cache handler, but Babel has been called synchronously`);
+    if ((0, _async.isThenable)(key)) {
+      return key.then(key => {
+        this._pairs.push([key, fn]);
+        return key;
+      });
+    }
+    this._pairs.push([key, fn]);
+    return key;
+  }
+  invalidate(handler) {
+    this._invalidate = true;
+    return this.using(handler);
+  }
+  validator() {
+    const pairs = this._pairs;
+    return function* (data) {
+      for (const [key, fn] of pairs) {
+        if (key !== (yield* fn(data))) return false;
+      }
+      return true;
+    };
+  }
+  deactivate() {
+    this._active = false;
+  }
+  configured() {
+    return this._configured;
+  }
+}
+function makeSimpleConfigurator(cache) {
+  function cacheFn(val) {
+    if (typeof val === "boolean") {
+      if (val) cache.forever();else cache.never();
+      return;
+    }
+    return cache.using(() => assertSimpleType(val()));
+  }
+  cacheFn.forever = () => cache.forever();
+  cacheFn.never = () => cache.never();
+  cacheFn.using = cb => cache.using(() => assertSimpleType(cb()));
+  cacheFn.invalidate = cb => cache.invalidate(() => assertSimpleType(cb()));
+  return cacheFn;
+}
+function assertSimpleType(value) {
+  if ((0, _async.isThenable)(value)) {
+    throw new Error(`You appear to be using an async cache handler, ` + `which your current version of Babel does not support. ` + `We may add support for this in the future, ` + `but if you're on the most recent version of @babel/core and still ` + `seeing this error, then you'll need to synchronously handle your caching logic.`);
+  }
+  if (value != null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number") {
+    throw new Error("Cache keys must be either string, boolean, number, null, or undefined.");
+  }
+  return value;
+}
+class Lock {
+  constructor() {
+    this.released = false;
+    this.promise = void 0;
+    this._resolve = void 0;
+    this.promise = new Promise(resolve => {
+      this._resolve = resolve;
+    });
+  }
+  release(value) {
+    this.released = true;
+    this._resolve(value);
+  }
+}
+0 && 0;
+
+//# sourceMappingURL=caching.js.map