@arken/node 1.5.0 → 1.5.2

package/modules/job/job.types.ts

@@ -1,23 +0,0 @@
-// module/job.types.ts
-
-import { z } from 'zod';
-import * as schema from './job.schema';
-import { Document, Model } from '../../util/mongo';
-import type { RouterContext } from '../../types';
-import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import type { Router } from './job.router';
-
-export type * from './job.router';
-export type * from './job.service';
-export type { RouterContext };
-
-export type Job = z.infer<typeof schema.Job>;
-
-export type JobDocument = Job & Document;
-
-export type Mappings = {
-  Job: Model<JobDocument>;
-};
-
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/market/index.ts

@@ -1,5 +0,0 @@
-export * as Types from './market.types';
-export * as Models from './market.models';
-export * as Schemas from './market.schema';
-export * from './market.router';
-export * from './market.service';

package/modules/market/market.models.ts

@@ -1,113 +0,0 @@
-import * as mongo from '../../util/mongo';
-import type * as Types from './market.types';
-
-export const Market = mongo.createModel<Types.MarketDocument>('Market', {
-  value: { type: String, required: true },
-});
-
-export const MarketPair = mongo.createModel<Types.MarketPairDocument>('MarketPair', {
-  value: { type: String, required: true },
-});
-
-export const MarketExchange = mongo.createModel<Types.MarketExchangeDocument>('MarketExchange', {
-  value: { type: String },
-});
-
-export const MarketAnalysis = mongo.createModel<Types.MarketAnalysisDocument>('MarketAnalysis', {
-  action: { type: String, required: true },
-  asset: { type: String, required: true },
-  signalType: { type: String, required: true },
-  confidence: { type: Number, required: true },
-  riskLevel: { type: String, required: true },
-  timeFrame: { type: String, required: true },
-  source: { type: String, required: true },
-  summary: { type: String, required: true },
-  labels: {
-    sector: { type: String },
-    topic: { type: String },
-    sentiment: { type: String },
-  },
-});
-
-export const MarketInvestor = mongo.createModel<Types.MarketInvestorDocument>('MarketInvestor', {
-  portfolioIds: [{ type: mongo.Schema.Types.ObjectId, required: true }],
-  totalPnl: { type: Number },
-});
-
-export const MarketInvestmentPortfolio = mongo.createModel<Types.MarketInvestmentPortfolioDocument>(
-  'MarketInvestmentPortfolio',
-  {
-    categoryGoals: [
-      {
-        category: { type: String, required: true },
-        goalPercentage: { type: Number, required: true },
-        currentPnL: { type: Number },
-        historicalPnL: { type: Number },
-      },
-    ],
-    investmentIds: [{ type: mongo.Schema.Types.ObjectId, required: true }],
-    totalPnl: { type: Number },
-  }
-);
-
-export const MarketInvestment = mongo.createModel<Types.MarketInvestmentDocument>('MarketInvestment', {
-  type: { type: String, required: true },
-  amount: { type: Number, required: true },
-  category: { type: String, required: true },
-  purchasePrice: { type: Number, required: true },
-  currentValue: { type: Number, required: true },
-  pnl: { type: Number, required: true },
-  transactions: [
-    {
-      date: { type: Date, required: true },
-      type: { type: String, required: true },
-      price: { type: Number, required: true },
-      quantity: { type: Number, required: true },
-    },
-  ],
-  stockId: { type: mongo.Schema.Types.ObjectId },
-  chainTokenId: { type: mongo.Schema.Types.ObjectId },
-});
-
-export const MarketStock = mongo.createModel<Types.MarketStockDocument>('MarketStock', {
-  ticker: { type: String, required: true },
-  companyId: { type: mongo.Schema.Types.ObjectId, required: true, ref: 'StockCompany' },
-  currentPrice: { type: Number, required: true },
-  marketCap: { type: Number },
-  volume: { type: Number },
-  currency: { type: String, required: true },
-  aum: { type: Number },
-  quoteType: { type: String },
-  dailyChange: { type: Number },
-  dailyChangePercent: { type: Number },
-});
-
-export const MarketToken = mongo.createModel<Types.MarketTokenDocument>('MarketToken', {
-  symbol: { type: String, required: true },
-  currentPrice: { type: Number, required: true },
-});
-
-export const MarketCompany = mongo.createModel<Types.MarketCompanyDocument>('MarketCompany', {
-  ticker: { type: String, required: true },
-  country: { type: String, required: true },
-  industry: { type: String, required: true },
-  sector: { type: String, required: true },
-  type: { type: String, required: true },
-  issuedETFs: [{ type: mongo.Schema.Types.ObjectId, ref: 'MarketETF' }],
-});
-
-export const MarketETF = mongo.createModel<Types.MarketETFDocument>('ETF', {
-  ticker: { type: String, required: true },
-  issuerId: { type: mongo.Schema.Types.ObjectId, required: true },
-  leverage: { type: Number, required: false },
-});
-
-export const MarketStockSentiment = mongo.createModel<Types.MarketStockSentimentDocument>('MarketStockSentiment', {
-  ticker: { type: String, required: true },
-  companyId: { type: mongo.Schema.Types.ObjectId, required: true, ref: 'StockCompany' },
-  sentiment: {
-    label: { type: String, required: true },
-    score: { type: Number, required: true },
-  },
-  confidence: { type: Number, required: true },
-});

package/modules/market/market.router.ts

@@ -1,73 +0,0 @@
-// module/market.router.ts
-
-import { z as zod } from 'zod';
-import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/rpc';
-import type { RouterContext } from '../../types';
-import { Market, MarketPair, MarketExchange } from './market.schema';
-
-export const z = zod;
-export const t = initTRPC.context<RouterContext>().create();
-export const router = t.router;
-export const procedure = t.procedure;
-
-export const createRouter = () =>
-  router({
-    getMarket: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ marketId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Market.getMarket as any)(input, ctx)),
-
-    createMarket: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(Market)
-      .mutation(({ input, ctx }) => (ctx.app.service.Market.createMarket as any)(input, ctx)),
-
-    updateMarket: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ marketId: z.string(), data: Market.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Market.updateMarket as any)(input, ctx)),
-
-    getMarketPair: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ marketPairId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Market.getMarketPair as any)(input, ctx)),
-
-    createMarketPair: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(MarketPair)
-      .mutation(({ input, ctx }) => (ctx.app.service.Market.createMarketPair as any)(input, ctx)),
-
-    updateMarketPair: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ marketPairId: z.string(), data: MarketPair.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Market.updateMarketPair as any)(input, ctx)),
-
-    getMarketExchange: procedure
-      .use(hasRole('guest', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ exchangeId: z.string() }))
-      .query(({ input, ctx }) => (ctx.app.service.Market.getMarketExchange as any)(input, ctx)),
-
-    createMarketExchange: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(MarketExchange)
-      .mutation(({ input, ctx }) => (ctx.app.service.Market.createMarketExchange as any)(input, ctx)),
-
-    updateMarketExchange: procedure
-      .use(hasRole('admin', t))
-      .use(customErrorFormatter(t))
-      .input(z.object({ exchangeId: z.string(), data: MarketExchange.partial() }))
-      .mutation(({ input, ctx }) => (ctx.app.service.Market.updateMarketExchange as any)(input, ctx)),
-  });
-
-export type Router = ReturnType<typeof createRouter>;
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/market/market.schema.ts

@@ -1,140 +0,0 @@
-import { z, Entity, ObjectId } from '../../schema';
-
-export const Market = Entity.merge(
-  z.object({
-    value: z.string(),
-  })
-);
-
-export const MarketPair = Entity.merge(
-  z.object({
-    value: z.string(),
-  })
-);
-
-export const MarketExchange = Entity.merge(
-  z.object({
-    value: z.string(),
-  })
-);
-
-export const MarketAnalysis = Entity.merge(
-  z.object({
-    action: z.enum(['Buy', 'Sell']), // buy or sell action
-    asset: z.string().min(1), // the asset being traded (e.g., oil, Bitcoin)
-    signalType: z.string().min(1), // type of signal (e.g., news)
-    confidence: z.number().min(0).max(100), // confidence level from 0 to 100
-    riskLevel: z.enum(['Low', 'Medium', 'High']), // risk level
-    timeFrame: z.enum(['Short-Term', 'Long-Term']), // investment time frame
-    source: z.string().min(1), // source of information (e.g., FinancialJuice, Ground News)
-    summary: z.string().min(1), // summary of the analysis
-    labels: z.object({
-      sector: z.string().optional(), // sector related to the asset (e.g., energy, aviation)
-      topic: z.string().optional(), // topic of the news (e.g., oil demand, job cuts)
-      sentiment: z.enum(['Positive', 'Neutral', 'Negative']).optional(), // sentiment of the news
-    }),
-  })
-);
-
-export const MarketInvestor = Entity.merge(
-  z.object({
-    portfolioIds: z.array(ObjectId), // Array of ObjectId references to InvestmentPortfolio
-    totalPnl: z.number().optional(), // Total profit and loss
-  })
-);
-
-export const MarketInvestmentPortfolio = Entity.merge(
-  z.object({
-    categoryGoals: z.array(
-      z.object({
-        category: z.string(), // Category name
-        goalPercentage: z.number(), // Goal percentage for this category
-        currentPnl: z.number().optional(), // Current P&L for this category
-        historicalPnL: z.number().optional(), // Historical P&L for this category
-      })
-    ), // Array of categories with goal percentages and P&L tracking
-    investmentIds: z.array(ObjectId), // Array of ObjectId references to Investment
-    totalPnl: z.number().optional(), // Total P&L for this portfolio
-  })
-);
-
-export const MarketInvestment = Entity.merge(
-  z.object({
-    type: z.enum(['Stock', 'ChainToken']),
-    category: z.enum(['Historically Safe', 'Economy Bull', 'Economy Bear', 'Custom']),
-    amount: z.number(), // Initial amount invested
-    purchasePrice: z.number(), // Price at which the investment was purchased
-    currentValue: z.number().optional(), // Current value of the investment
-    pnl: z.number().optional(), // Current P&L of the investment
-    transactions: z
-      .array(
-        z.object({
-          date: z.string(), // Date of transaction
-          type: z.enum(['Buy', 'Sell']),
-          price: z.number(), // Price at transaction
-          quantity: z.number(), // Quantity bought or sold
-        })
-      )
-      .optional(), // Optional array for detailed transaction history
-    stockId: ObjectId.optional(), // Reference to Stock if type is 'Stock'
-    chainTokenId: ObjectId.optional(), // Reference to ChainToken if type is 'ChainToken'
-  })
-);
-
-export const MarketStock = Entity.merge(
-  z.object({
-    ticker: z.string(),
-    companyId: ObjectId,
-    marketCap: z.number().optional(),
-    aum: z.number().optional(),
-    quoteType: z.string(),
-    currentPrice: z.number(),
-    dailyChange: z.number().optional(),
-    dailyChangePercent: z.number().optional(),
-    volume: z.number(),
-    currency: z.string(),
-  })
-);
-
-export const MarketToken = Entity.merge(
-  z.object({
-    symbol: z.string(),
-    currentPrice: z.number(),
-  })
-);
-
-export const MarketCompany = Entity.merge(
-  z.object({
-    ticker: z.string(), // Primary ticker, if applicable
-    type: z.enum(['Public Company', 'ETF Issuer', 'Both', 'Other']), // Categorize the company type
-    country: z.string().optional(), // Country where the company is based
-    industry: z.string().optional(), // Industry the company operates in
-    sector: z.string().optional(), // Sector the company belongs to
-    issuedETFs: z.array(ObjectId).optional(), // References to ETFs issued by this company
-  })
-);
-
-export const MarketETF = Entity.merge(
-  z.object({
-    ticker: z.string(),
-    issuerId: ObjectId, // Reference to the Company issuing the ETF
-    leverage: z.number().optional(), // Leverage factor if applicable (e.g., 3x)
-    country: z.string().optional(), // Country where the ETF is based
-    currency: z.string().optional(), // Currency the ETF is traded in
-    AUM: z.number().optional(), // Assets under management
-    industry: z.string().optional(), // Industry the ETF is focused on
-    sector: z.string().optional(), // Sector the ETF is focused on
-  })
-);
-
-export const MarketStockSentiment = Entity.merge(
-  z.object({
-    ticker: z.string(),
-    companyId: ObjectId,
-    sentiment: z.object({
-      label: z.enum(['Positive', 'Neutral', 'Negative']), // predefined sentiment labels
-      score: z.number().min(0).max(1), // sentiment score as a confidence percentage
-    }),
-    confidence: z.number().min(0).max(1), // overall confidence level for the analysis
-  })
-);

package/modules/market/market.service.ts

@@ -1,122 +0,0 @@
-// module/market.service.ts
-
-import type {
-  Market,
-  MarketPair,
-  MarketExchange,
-  RouterContext,
-  Router,
-  RouterInput,
-  RouterOutput,
-} from './market.types';
-
-export class Service {
-  async getMarket(input: RouterInput['getMarket'], ctx: RouterContext): Promise<RouterOutput['getMarket']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.getMarket', input.marketId);
-
-    const market = await ctx.app.model.Market.findById(input.marketId).lean().exec();
-    if (!market) throw new Error('Market not found');
-
-    return market as Market;
-  }
-
-  async createMarket(input: RouterInput['createMarket'], ctx: RouterContext): Promise<RouterOutput['createMarket']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.createMarket', input);
-
-    const market = await ctx.app.model.Market.create(input);
-    return market as Market;
-  }
-
-  async updateMarket(input: RouterInput['updateMarket'], ctx: RouterContext): Promise<RouterOutput['updateMarket']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.updateMarket', input.marketId, input.data);
-
-    const updatedMarket = await ctx.app.model.Market.findByIdAndUpdate(input.marketId, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedMarket) throw new Error('Market update failed');
-
-    return updatedMarket as Market;
-  }
-
-  async getMarketPair(input: RouterInput['getMarketPair'], ctx: RouterContext): Promise<RouterOutput['getMarketPair']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.getMarketPair', input.marketPairId);
-
-    const marketPair = await ctx.app.model.MarketPair.findById(input.marketPairId).lean().exec();
-    if (!marketPair) throw new Error('MarketPair not found');
-
-    return marketPair as MarketPair;
-  }
-
-  async createMarketPair(
-    input: RouterInput['createMarketPair'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createMarketPair']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.createMarketPair', input);
-
-    const marketPair = await ctx.app.model.MarketPair.create(input);
-    return marketPair as MarketPair;
-  }
-
-  async updateMarketPair(
-    input: RouterInput['updateMarketPair'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateMarketPair']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.updateMarketPair', input.marketPairId, input.data);
-
-    const updatedMarketPair = await ctx.app.model.MarketPair.findByIdAndUpdate(input.marketPairId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedMarketPair) throw new Error('MarketPair update failed');
-
-    return updatedMarketPair as MarketPair;
-  }
-
-  async getMarketExchange(
-    input: RouterInput['getMarketExchange'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getMarketExchange']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.getMarketExchange', input.exchangeId);
-
-    const marketExchange = await ctx.app.model.MarketExchange.findById(input.exchangeId).lean().exec();
-    if (!marketExchange) throw new Error('MarketExchange not found');
-
-    return marketExchange as MarketExchange;
-  }
-
-  async createMarketExchange(
-    input: RouterInput['createMarketExchange'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createMarketExchange']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.createMarketExchange', input);
-
-    const marketExchange = await ctx.app.model.MarketExchange.create(input);
-    return marketExchange as MarketExchange;
-  }
-
-  async updateMarketExchange(
-    input: RouterInput['updateMarketExchange'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateMarketExchange']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Market.Service.updateMarketExchange', input.exchangeId, input.data);
-
-    const updatedMarketExchange = await ctx.app.model.MarketExchange.findByIdAndUpdate(input.exchangeId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedMarketExchange) throw new Error('MarketExchange update failed');
-
-    return updatedMarketExchange as MarketExchange;
-  }
-}

package/modules/market/market.types.ts

@@ -1,56 +0,0 @@
-// module/market.types.ts
-
-import { z } from 'zod';
-import * as schema from './market.schema';
-import { Document, Model } from '../../util/mongo';
-import type { RouterContext } from '../../types';
-import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import type { Router } from './market.router';
-
-export type * from './market.router';
-export type * from './market.service';
-export type { RouterContext };
-
-export type Market = z.infer<typeof schema.Market>;
-export type MarketPair = z.infer<typeof schema.MarketPair>;
-export type MarketExchange = z.infer<typeof schema.MarketExchange>;
-export type MarketAnalysis = z.infer<typeof schema.MarketAnalysis>;
-export type MarketInvestor = z.infer<typeof schema.MarketInvestor>;
-export type MarketInvestmentPortfolio = z.infer<typeof schema.MarketInvestmentPortfolio>;
-export type MarketInvestment = z.infer<typeof schema.MarketInvestment>;
-export type MarketStock = z.infer<typeof schema.MarketStock>;
-export type MarketToken = z.infer<typeof schema.MarketToken>;
-export type MarketCompany = z.infer<typeof schema.MarketCompany>;
-export type MarketETF = z.infer<typeof schema.MarketETF>;
-export type MarketStockSentiment = z.infer<typeof schema.MarketStockSentiment>;
-
-export type MarketDocument = Market & Document;
-export type MarketPairDocument = MarketPair & Document;
-export type MarketExchangeDocument = MarketExchange & Document;
-export type MarketAnalysisDocument = MarketAnalysis & Document;
-export type MarketInvestorDocument = MarketInvestor & Document;
-export type MarketInvestmentPortfolioDocument = MarketInvestmentPortfolio & Document;
-export type MarketInvestmentDocument = MarketInvestment & Document;
-export type MarketStockDocument = MarketStock & Document;
-export type MarketTokenDocument = MarketToken & Document;
-export type MarketCompanyDocument = MarketCompany & Document;
-export type MarketETFDocument = MarketETF & Document;
-export type MarketStockSentimentDocument = MarketStockSentiment & Document;
-
-export type Mappings = {
-  Market: Model<MarketDocument>;
-  MarketPair: Model<MarketPairDocument>;
-  MarketExchange: Model<MarketExchangeDocument>;
-  MarketAnalysis: Model<MarketAnalysisDocument>;
-  MarketInvestor: Model<MarketInvestorDocument>;
-  MarketInvestmentPortfolio: Model<MarketInvestmentPortfolioDocument>;
-  MarketInvestment: Model<MarketInvestmentDocument>;
-  MarketStock: Model<MarketStockDocument>;
-  MarketToken: Model<MarketTokenDocument>;
-  MarketCompany: Model<MarketCompanyDocument>;
-  MarketETF: Model<MarketETFDocument>;
-  MarketStockSentiment: Model<MarketStockSentimentDocument>;
-};
-
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/modules/product/index.ts

@@ -1,5 +0,0 @@
-export * as Types from './product.types';
-export * as Models from './product.models';
-export * as Schemas from './product.schema';
-export * from './product.router';
-export * from './product.service';