@tradejs/app 1.0.9 → 1.0.11

package/src/app/lib/cardPageLayout.ts

@@ -0,0 +1 @@
+export const CARD_PAGE_CONTENT_MAX_WIDTH = '1400px';

package/src/app/lib/connectorCreator.ts

@@ -0,0 +1,28 @@
+import { getConnectorCreatorByProvider as getBuiltinConnectorCreatorByProvider } from '@tradejs/connectors';
+import { getConnectorCreatorByProvider as getRegisteredConnectorCreatorByProvider } from '@tradejs/node/connectors';
+import { ConnectorCreator } from '@tradejs/types';
+
+export const DEFAULT_CONNECTOR_PROVIDER = 'bybit';
+
+export const resolveConnectorCreatorByProvider = async (
+  provider: string,
+  projectRoot: string,
+  fallbackProvider = DEFAULT_CONNECTOR_PROVIDER,
+): Promise<ConnectorCreator | null> => {
+  const registeredConnector =
+    (await getRegisteredConnectorCreatorByProvider(provider, projectRoot)) ||
+    (await getRegisteredConnectorCreatorByProvider(
+      fallbackProvider,
+      projectRoot,
+    ));
+
+  if (registeredConnector) {
+    return registeredConnector as ConnectorCreator;
+  }
+
+  return (
+    getBuiltinConnectorCreatorByProvider(provider) ||
+    getBuiltinConnectorCreatorByProvider(fallbackProvider) ||
+    null
+  );
+};

package/src/app/lib/currentUser.ts

@@ -1,4 +1,4 @@
-import { auth } from '@app/auth';
+import { auth } from '#app/auth';
 
 type SessionLike = {
   user?: {

package/src/app/lib/errorMessage.ts

@@ -0,0 +1,34 @@
+const getStringField = (value: unknown, key: string) => {
+  if (!value || typeof value !== 'object') return null;
+
+  const field = (value as Record<string, unknown>)[key];
+  if (typeof field === 'string' && field.trim()) return field.trim();
+  if (key === 'code' && typeof field === 'number') return String(field);
+  return null;
+};
+
+export const getErrorMessage = (error: unknown) => {
+  if (error instanceof Error && error.message.trim()) {
+    return error.message.trim();
+  }
+
+  if (typeof error === 'string' && error.trim()) {
+    return error.trim();
+  }
+
+  const code = getStringField(error, 'code');
+  const message = getStringField(error, 'message');
+  const body = getStringField(error, 'body');
+  const details = [code, message].filter(Boolean).join(' ');
+
+  if (details || body) {
+    return [details, body].filter(Boolean).join(': ');
+  }
+
+  try {
+    const serialized = JSON.stringify(error);
+    return serialized && serialized !== '{}' ? serialized : 'Unknown error';
+  } catch {
+    return 'Unknown error';
+  }
+};

package/src/app/lib/installation.ts

@@ -0,0 +1,83 @@
+import bcrypt from 'bcryptjs';
+import { getData, redisKeys, setData } from '@tradejs/infra/redis';
+import type { StrategyConfigGrid } from '@tradejs/types';
+
+export const INSTALL_USER_NAME = 'root';
+export const FIRST_BACKTEST_CONFIG_ID = 'MaStrategy:base';
+
+export const FIRST_BACKTEST_CONFIG: StrategyConfigGrid = {
+  INTERVAL: ['15'],
+  MAX_LOSS_VALUE: [10],
+  MA_FAST: [21],
+  MA_SLOW: [55],
+  LONG: [
+    {
+      enable: true,
+      direction: 'LONG',
+      TP: 2,
+      SL: 1,
+      minRiskRatio: 1.2,
+    },
+  ],
+  SHORT: [
+    {
+      enable: true,
+      direction: 'SHORT',
+      TP: 2,
+      SL: 1,
+      minRiskRatio: 1.2,
+    },
+  ],
+};
+
+export const getPasswordHash = (user: unknown): string | null => {
+  if (!user) return null;
+  if (typeof user === 'string') return user;
+  if (typeof user !== 'object') return null;
+
+  const record = user as Record<string, unknown>;
+  const direct = record.passwordHash ?? record.password;
+  if (typeof direct === 'string') return direct;
+
+  const nested = record.password as Record<string, unknown> | undefined;
+  const nestedHash = nested?.hash;
+  if (typeof nestedHash === 'string') return nestedHash;
+
+  const alt = record.hash;
+  return typeof alt === 'string' ? alt : null;
+};
+
+export const isInstallationRequired = async () => {
+  const user = await getData(redisKeys.user(INSTALL_USER_NAME), null);
+  return !getPasswordHash(user);
+};
+
+export const initializeInstallation = async (password: string) => {
+  const existing = (await getData(
+    redisKeys.user(INSTALL_USER_NAME),
+    null,
+  )) as Record<string, unknown> | null;
+
+  if (getPasswordHash(existing)) {
+    return false;
+  }
+
+  const passwordHash = await bcrypt.hash(password, 10);
+  await setData(
+    redisKeys.user(INSTALL_USER_NAME),
+    {
+      ...(existing ?? {}),
+      passwordHash,
+      userName: INSTALL_USER_NAME,
+      updatedAt: new Date().toISOString(),
+    },
+    { expire: 0 },
+  );
+  await setData(
+    redisKeys.backtestConfig(INSTALL_USER_NAME, FIRST_BACKTEST_CONFIG_ID),
+    FIRST_BACKTEST_CONFIG,
+    { expire: 0 },
+  );
+
+  return true;
+};

package/src/app/lib/marketDefaults.ts

@@ -0,0 +1,12 @@
+import type { MarketUniverse, Provider } from '@tradejs/types';
+
+export const getDefaultMarketSymbol = (
+  provider: Provider,
+  universe: MarketUniverse,
+) => {
+  if (universe === 'tradfi') {
+    return 'AAPLUSDT';
+  }
+
+  return 'BTCUSDT';
+};

package/src/app/lib/marketRoutes.ts

@@ -0,0 +1,58 @@
+import {
+  Interval,
+  isMarketUniverse,
+  MarketUniverse,
+  Provider,
+} from '@tradejs/types';
+
+interface MarketRouteParts {
+  provider: string;
+  universe: MarketUniverse;
+  symbol: string;
+  interval: string;
+}
+
+interface DashboardRouteParts {
+  provider: Provider;
+  universe: MarketUniverse;
+  symbol: string;
+  interval: Interval;
+}
+
+const appendRouteQuery = (pathname: string, searchParams?: URLSearchParams) => {
+  const params = new URLSearchParams(searchParams);
+  const search = params.toString();
+  return `${pathname}${search ? `?${search}` : ''}`;
+};
+
+export const buildKlinePath = ({
+  provider,
+  universe,
+  symbol,
+  interval,
+}: MarketRouteParts) =>
+  `/api/kline/${provider}/${universe}/${symbol}/${interval}`;
+
+export const buildDashboardPath = (
+  { provider, universe, symbol, interval }: MarketRouteParts,
+  searchParams?: URLSearchParams,
+) =>
+  appendRouteQuery(
+    `/routes/dashboard/${provider}/${universe}/${symbol}/${interval}`,
+    searchParams,
+  );
+
+export const parseDashboardPath = (
+  pathname: string,
+  fallback: Omit<DashboardRouteParts, 'universe'>,
+): DashboardRouteParts => {
+  const parts = pathname.split('/').filter(Boolean);
+  const rawUniverse = parts[3];
+
+  return {
+    provider: (parts[2] || fallback.provider) as Provider,
+    universe: isMarketUniverse(rawUniverse) ? rawUniverse : 'crypto',
+    symbol: parts[4] || fallback.symbol,
+    interval: (parts[5] || fallback.interval) as Interval,
+  };
+};