@arken/seer-protocol 0.1.1 → 0.1.2

package/market/market.router.ts

@@ -0,0 +1,73 @@
+// 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/market/market.schema.ts

@@ -0,0 +1,140 @@
+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/market/market.types.ts

@@ -0,0 +1,56 @@
+// 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/oasis/oasis.models.ts

@@ -1,3 +1,3 @@
-import * as mongo from '@arken/mongo';
+import * as mongo from '@arken/node/mongo';
 
 const { addTagVirtuals, addApplicationVirtual } = mongo;

package/oasis/oasis.router.ts

@@ -1,8 +1,8 @@
 import { z as zod } from 'zod';
 import { initTRPC } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '@arken/rpc';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
 import * as Arken from '@arken/node';
-import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/schema';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '@arken/node/schema';
 import { RouterContext } from '../../types';
 
 export const z = zod;

package/oasis/oasis.schema.ts

@@ -1 +1 @@
-import { z, ObjectId, Entity } from '@arken/schema';
+import { z, ObjectId, Entity } from '@arken/node/schema';

package/oasis/oasis.types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Model, Document } from '@arken/mongo';
+import { Model, Document } from '@arken/node/mongo';
 import * as schema from './oasis.schema';
 
 export type * from './oasis.router';

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "@arken/seer-protocol",
-  "version": "0.1.1",
-  "main": "src/index.ts",
-  "scripts": {},
+  "version": "0.1.2",
+  "main": "index.ts",
+  "scripts": {
+    "build": "npm-run-all dist",
+    "clean": "del-cli ./build && make-dir ./build",
+    "dist": "npm-run-all clean tsc:*",
+    "publish": "npm publish --access=public",
+    "tsc:1": "rm -rf ./build && mkdir ./build && cp package.json ./build && NODE_ENV=production NODE_OPTIONS=--max-old-space-size=8192 tsc"
+  },
   "dependencies": {
+    "@arken/node": "^1.5.2",
     "@arken/forge-protocol": "^0.1.1",
     "@trpc/client": "11.0.0-rc.660",
     "@trpc/server": "11.0.0-rc.660",

package/product/index.ts

@@ -0,0 +1,5 @@
+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';

package/product/product.models.ts

@@ -0,0 +1,166 @@
+import * as mongo from '../../util/mongo';
+import type * as Types from './product.types';
+
+export const Product = mongo.createModel<Types.ProductDocument>(
+  'Product',
+  {
+    shortDescription: { type: String, maxlength: 300, required: false },
+    content: { type: String, required: false },
+    communityId: { type: mongo.Schema.Types.ObjectId, ref: 'Community', required: false },
+    type: { type: String, default: 'game', maxlength: 100 },
+    releaseDate: { type: Date },
+
+    // New fields from Objection.js model
+    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'Product' },
+    score: { type: Number },
+    ownerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' },
+    ratingId: { type: mongo.Schema.Types.ObjectId, ref: 'Rating' },
+    ideaId: { type: mongo.Schema.Types.ObjectId, ref: 'Idea' },
+    meta: {
+      name: String,
+      members: [{ type: mongo.Schema.Types.ObjectId, ref: 'Profile' }],
+      isProposal: Boolean,
+      price: Number,
+      oldPrice: Number,
+      images: Object,
+      video: String,
+      genre: String,
+      releaseDate: String,
+      developer: String,
+      publisher: String,
+      developerTags: [String],
+      languageSupport: [Object], // Adjust as needed
+      systemRequirements: [Object], // Adjust as needed
+      tags: [{ type: mongo.Schema.Types.ObjectId, ref: 'Tag' }],
+      type: String,
+      downloads: Number,
+      plans: [Object], // Adjust as needed
+      frequentlyTradedAssets: [{ type: mongo.Schema.Types.ObjectId, ref: 'Asset' }],
+      saleBox: Object,
+      assets: [{ type: mongo.Schema.Types.ObjectId, ref: 'Asset' }],
+      community: Object,
+      nameUrl: String,
+      steamId: Number,
+      author: String,
+    },
+  },
+  {
+    virtuals: [
+      {
+        name: 'projects',
+        ref: 'Project',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      {
+        name: 'leaderboards',
+        ref: 'Leaderboard',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      {
+        name: 'games',
+        ref: 'Game',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      {
+        name: 'productUpdates',
+        ref: 'ProductUpdate',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      // Adding missing relations as virtuals
+      {
+        name: 'owner',
+        ref: 'Profile',
+        localField: 'ownerId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'rating',
+        ref: 'Rating',
+        localField: 'ratingId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'community',
+        ref: 'Community',
+        localField: 'communityId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'idea',
+        ref: 'Idea',
+        localField: 'ideaId',
+        foreignField: '_id',
+        justOne: true,
+      },
+      {
+        name: 'subproducts',
+        ref: 'Product',
+        localField: '_id',
+        foreignField: 'parentId',
+      },
+      {
+        name: 'servers',
+        ref: 'Server',
+        localField: '_id',
+        foreignField: 'productId',
+      },
+      // {
+      //   name: 'votes',
+      //   ref: 'Vote',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.toProductId',
+      //     to: 'nodes.fromVoteId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+      // {
+      //   name: 'files',
+      //   ref: 'File',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.fromProductId',
+      //     to: 'nodes.toFileId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+      // {
+      //   name: 'tags',
+      //   ref: 'Tag',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.fromProductId',
+      //     to: 'nodes.toTagId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+      // {
+      //   name: 'internalTags',
+      //   ref: 'Tag',
+      //   localField: '_id',
+      //   foreignField: 'productId',
+      //   through: {
+      //     from: 'nodes.fromProductId',
+      //     to: 'nodes.toTagId',
+      //     extra: ['relationKey'],
+      //   },
+      // },
+    ],
+  }
+);
+
+export const ProductUpdate = mongo.createModel<Types.ProductUpdateDocument>('ProductUpdate', {
+  productId: { type: mongo.Schema.Types.ObjectId, ref: 'Product', required: true },
+  updateContent: { type: String, required: true },
+  updateDate: { type: Date, required: true },
+});

package/product/product.router.ts

@@ -0,0 +1,93 @@
+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 { Product, ProductDLC, ProductBundle, ProductReview } from './product.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({
+    // Product endpoints
+    getProduct: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ productId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProduct as any)(input, ctx)),
+
+    createProduct: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(Product)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProduct as any)(input, ctx)),
+
+    updateProduct: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ productId: z.string(), data: Product.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProduct as any)(input, ctx)),
+
+    // ProductDLC endpoints
+    getProductDLC: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ dlcId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProductDLC as any)(input, ctx)),
+
+    createProductDLC: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(ProductDLC)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProductDLC as any)(input, ctx)),
+
+    updateProductDLC: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ dlcId: z.string(), data: ProductDLC.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProductDLC as any)(input, ctx)),
+
+    // ProductBundle endpoints
+    getProductBundle: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ bundleId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProductBundle as any)(input, ctx)),
+
+    createProductBundle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(ProductBundle)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProductBundle as any)(input, ctx)),
+
+    updateProductBundle: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ bundleId: z.string(), data: ProductBundle.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProductBundle as any)(input, ctx)),
+
+    // ProductReview endpoints
+    getProductReview: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ reviewId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Product.getProductReview as any)(input, ctx)),
+
+    createProductReview: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(ProductReview)
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.createProductReview as any)(input, ctx)),
+
+    updateProductReview: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ reviewId: z.string(), data: ProductReview.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Product.updateProductReview as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;