@arken/seer-protocol 0.1.1 → 0.1.3

package/area/area.models.ts

@@ -0,0 +1,15 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './area.types';
+
+export const Area = mongo.createModel<Types.AreaDocument>('Area', {
+  type: { type: String, default: 'Zone' },
+  shortDescription: { type: String },
+  // landmarks: [{ type: mongo.Schema.Types.ObjectId, ref: 'AreaLandmark' }],
+});
+
+export const AreaLandmark = mongo.createModel<Types.AreaLandmarkDocument>('AreaLandmark', {
+  areaId: { type: mongo.Schema.Types.ObjectId, ref: 'Area' },
+});
+
+export const AreaType = mongo.createModel<Types.AreaTypeDocument>('AreaType', {});
+export const AreaNameChoice = mongo.createModel<Types.AreaNameChoiceDocument>('AreaNameChoice', {});

package/area/area.router.ts

@@ -0,0 +1,74 @@
+import { z as zod } from 'zod';
+import { initTRPC } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Area, AreaLandmark, AreaType } from './area.schema';
+import { Query, getQueryInput, inferRouterOutputs, inferRouterInputs } from '../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({
+    getArea: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Area))
+      .query(({ input, ctx }) => (ctx.app.service.Area.getArea as any)(input, ctx)),
+
+    getAreas: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Area))
+      .query(({ input, ctx }) => (ctx.app.service.Area.getAreas as any)(input, ctx)),
+
+    saveArea: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Area))
+      .output(Area.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Area.saveArea as any)(input, ctx)),
+
+    getAreaLandmark: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Area.getAreaLandmark as any)(input, ctx)),
+
+    createAreaLandmark: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: AreaLandmark.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Area.createAreaLandmark as any)(input, ctx)),
+
+    updateAreaLandmark: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: AreaLandmark.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Area.updateAreaLandmark as any)(input, ctx)),
+
+    getAreaType: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query }))
+      .query(({ input, ctx }) => (ctx.app.service.Area.getAreaType as any)(input, ctx)),
+
+    createAreaType: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ data: AreaType.omit({ id: true }) }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Area.createAreaType as any)(input, ctx)),
+
+    updateAreaType: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ query: Query, data: AreaType.partial() }))
+      .output(AreaType.partial())
+      .mutation(({ input, ctx }) => (ctx.app.service.Area.updateAreaType as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/area/area.schema.ts

@@ -0,0 +1,22 @@
+// arken/packages/node/modules/area/area.schema.ts
+//
+import { z, ObjectId, Entity } from '../schema';
+
+export const Area = Entity.merge(
+  z.object({
+    type: z.string().default('Zone'),
+    landmarks: z.array(ObjectId).optional(),
+    shortDescription: z.string(),
+  })
+);
+
+export const AreaLandmark = Entity.merge(
+  z.object({
+    areaId: ObjectId.optional(),
+    area: ObjectId.optional(),
+  })
+);
+
+export const AreaType = Entity.merge(z.object({}));
+
+export const AreaNameChoice = Entity.merge(z.object({}));

package/area/area.types.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import * as schema from './area.schema';
+import { Document, Model } from '@arken/node/mongo';
+
+export type * from './area.router';
+export type { RouterContext } from '../types';
+
+export type Area = z.infer<typeof schema.Area>;
+export type AreaDocument = Area & Document;
+
+export type AreaLandmark = z.infer<typeof schema.AreaLandmark>;
+export type AreaLandmarkDocument = AreaLandmark & Document;
+
+export type AreaType = z.infer<typeof schema.AreaType>;
+export type AreaTypeDocument = AreaType & Document;
+
+export type AreaNameChoice = z.infer<typeof schema.AreaNameChoice>;
+export type AreaNameChoiceDocument = AreaNameChoice & Document;
+
+export type Mappings = {
+  Area: Model<AreaDocument>;
+  AreaLandmark: Model<AreaLandmarkDocument>;
+  AreaType: Model<AreaTypeDocument>;
+  AreaNameChoice: Model<AreaNameChoiceDocument>;
+};

package/area/index.ts

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

package/asset/asset.models.ts

@@ -0,0 +1,59 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './asset.types';
+
+export const AssetStandard = mongo.createModel<Types.AssetStandardDocument>(
+  'AssetStandard',
+  {
+    version: { type: String, required: false },
+    parentId: { type: mongo.Schema.Types.ObjectId, ref: 'AssetStandard', required: false },
+  },
+  {
+    virtuals: [
+      {
+        name: 'children',
+        ref: 'AssetStandard',
+        localField: '_id',
+        foreignField: 'parent',
+        justOne: false,
+      },
+    ],
+  }
+);
+
+export const Asset = mongo.createModel<Types.AssetDocument>(
+  'Asset',
+  {
+    uri: { type: String, required: true },
+    type: { type: String, maxlength: 100, required: true },
+    standards: [{ type: mongo.Schema.Types.ObjectId, ref: 'AssetStandard', required: true }],
+    licenseId: { type: mongo.Schema.Types.ObjectId, ref: 'AssetLicense' },
+    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain' },
+    ownerId: { type: mongo.Schema.Types.ObjectId, ref: 'Profile' }, // Added ownerId
+    // skin: { type: String },
+    // transmuteCount: { type: Number },
+    // score: { type: Number },
+  },
+  {
+    virtuals: [
+      {
+        name: 'items',
+        ref: 'Item',
+        localField: '_id',
+        foreignField: 'assetId',
+      },
+      {
+        name: 'offers',
+        ref: 'Node',
+        localField: '_id',
+        foreignField: 'fromOfferId',
+        justOne: false,
+        match: { relationKey: 'offers' },
+      },
+    ],
+  }
+);
+
+export const AssetLicense = mongo.createModel<Types.AssetLicenseDocument>('AssetLicense', {
+  value: { type: String, required: true },
+  // assets: [{ type: mongo.Schema.Types.ObjectId, ref: 'Asset' }],
+});

package/asset/asset.router.ts

@@ -0,0 +1,55 @@
+// module/asset.router.ts
+
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs, inferRouterOutputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Asset, AssetLicense } from './asset.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({
+    getAsset: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ assetId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Asset.getAsset as any)(input, ctx)),
+
+    createAsset: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(Asset)
+      .mutation(({ input, ctx }) => (ctx.app.service.Asset.createAsset as any)(input, ctx)),
+
+    updateAsset: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ assetId: z.string(), data: Asset.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Asset.updateAsset as any)(input, ctx)),
+
+    getAssetLicense: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ assetLicenseId: z.string() }))
+      .query(({ input, ctx }) => (ctx.app.service.Asset.getAssetLicense as any)(input, ctx)),
+
+    createAssetLicense: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(AssetLicense)
+      .mutation(({ input, ctx }) => (ctx.app.service.Asset.createAssetLicense as any)(input, ctx)),
+
+    updateAssetLicense: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(z.object({ assetLicenseId: z.string(), data: AssetLicense.partial() }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Asset.updateAssetLicense as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/asset/asset.schema.ts

@@ -0,0 +1,30 @@
+import { z, ObjectId, Entity } from '../schema';
+
+export const AssetStandard = Entity.merge(
+  z.object({
+    version: z.string().optional(),
+    parentId: ObjectId.optional(),
+  })
+);
+
+export const Asset = Entity.merge(
+  z.object({
+    uri: z.string().min(1),
+    type: z
+      .string()
+      .max(100)
+      .min(1),
+    standards: z.array(ObjectId),
+    licenseId: ObjectId.optional(),
+    license: ObjectId.optional(),
+    chainId: ObjectId.optional(),
+    items: z.array(ObjectId).optional(),
+  })
+);
+
+export const AssetLicense = Entity.merge(
+  z.object({
+    value: z.string().min(1),
+    assets: z.array(ObjectId).optional(),
+  })
+);

package/asset/asset.types.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import * as schema from './asset.schema';
+import { Document, Model } from '@arken/node/mongo';
+
+export type * from './asset.router';
+export type { RouterContext } from '../types';
+
+export type Asset = z.infer<typeof schema.Asset>;
+export type AssetDocument = Asset & Document;
+
+export type AssetStandard = z.infer<typeof schema.AssetStandard>;
+export type AssetStandardDocument = AssetStandard & Document;
+
+export type AssetLicense = z.infer<typeof schema.AssetLicense>;
+export type AssetLicenseDocument = AssetLicense & Document;
+
+export type Mappings = {
+  Asset: Model<AssetDocument>;
+  AssetStandard: Model<AssetStandardDocument>;
+  AssetLicense: Model<AssetLicenseDocument>;
+};

package/asset/index.ts

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

package/chain/chain.models.ts

@@ -0,0 +1,50 @@
+import * as mongo from '@arken/node/mongo';
+import type * as Types from './chain.types';
+
+export const Chain = mongo.createModel<Types.ChainDocument>('Chain', {
+  content: { type: String, required: true },
+  type: { type: String, maxlength: 100, required: true },
+});
+
+export const ChainContract = mongo.createModel<Types.ChainContractDocument>('ChainContract', {
+  chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: true },
+  content: { type: String },
+  address: { type: String },
+  type: { type: String, maxlength: 100, required: true },
+  standards: [{ type: mongo.Schema.Types.ObjectId, ref: 'AssetStandard', required: true }],
+});
+
+export const ChainToken = mongo.createModel<Types.ChainTokenDocument>(
+  'ChainToken',
+  {
+    chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: true },
+    chainContractId: { type: mongo.Schema.Types.ObjectId, ref: 'ChainContract', required: true },
+    rank: { type: Number, min: 0, default: 0 },
+    description: { type: String, trim: true },
+    address: { type: String },
+    content: { type: String },
+    decimals: { type: Number, default: 0 },
+    price: { type: Number, min: 0, default: 0 },
+    hourChange: { type: Number, default: 0 },
+    dayChange: { type: Number, default: 0 },
+    weekChange: { type: Number, default: 0 },
+    marketCap: { type: Number, min: 0, default: 0 },
+    volume: { type: Number, min: 0, default: 0 },
+    symbol: { type: String, required: true, trim: true },
+    circulatingSupply: { type: Number, min: 0, default: 0 },
+    cmcLink: { type: String, trim: true },
+    movementDown: { type: Number, min: 0, default: 0 },
+    movementUp: { type: Number, min: 0, default: 0 },
+    enteredTop100: { type: Number, min: 0, default: 0 },
+    exitedTop100: { type: Number, min: 0, default: 0 },
+    largeMoveDown: { type: Number, min: 0, default: 0 },
+  },
+  {
+    indexes: [{ applicationId: 1, symbol: 1, unique: true }],
+  }
+);
+
+export const ChainTransaction = mongo.createModel<Types.ChainTransactionDocument>('ChainTransaction', {
+  value: { type: String, required: true },
+  chainId: { type: mongo.Schema.Types.ObjectId, ref: 'Chain', required: true },
+});

package/chain/chain.router.ts

@@ -0,0 +1,104 @@
+// module/chain.router.ts
+
+import { z as zod } from 'zod';
+import { initTRPC, inferRouterInputs } from '@trpc/server';
+import { customErrorFormatter, hasRole } from '@arken/node/rpc';
+import type { RouterContext } from '../types';
+import { Chain, ChainContract, ChainToken, ChainTransaction } from './chain.schema';
+import { Query, getQueryInput, getQueryOutput, inferRouterOutputs } from '../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({
+    getChain: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Chain))
+      .output(Chain)
+      .query(({ input, ctx }) => (ctx.app.service.Chain.getChain as any)(input, ctx)),
+
+    createChain: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Chain))
+      .output(Chain.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChain as any)(input, ctx)),
+
+    updateChain: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(Chain))
+      .output(Chain.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChain as any)(input, ctx)),
+
+    getChainContract: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainContract))
+      .output(ChainContract)
+      .query(({ input, ctx }) => (ctx.app.service.Chain.getChainContract as any)(input, ctx)),
+
+    createChainContract: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainContract))
+      .output(ChainContract.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChainContract as any)(input, ctx)),
+
+    updateChainContract: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainContract))
+      .output(ChainContract.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChainContract as any)(input, ctx)),
+
+    getChainToken: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainToken))
+      .output(ChainToken)
+      .query(({ input, ctx }) => (ctx.app.service.Chain.getChainToken as any)(input, ctx)),
+
+    createChainToken: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainToken))
+      .output(ChainToken.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChainToken as any)(input, ctx)),
+
+    updateChainToken: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainToken))
+      .output(ChainToken.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChainToken as any)(input, ctx)),
+
+    getChainTransaction: procedure
+      .use(hasRole('guest', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainTransaction))
+      .output(ChainTransaction)
+      .query(({ input, ctx }) => (ctx.app.service.Chain.getChainTransaction as any)(input, ctx)),
+
+    createChainTransaction: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainTransaction))
+      .output(ChainTransaction.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.createChainTransaction as any)(input, ctx)),
+
+    updateChainTransaction: procedure
+      .use(hasRole('admin', t))
+      .use(customErrorFormatter(t))
+      .input(getQueryInput(ChainTransaction))
+      .output(ChainTransaction.pick({ id: true }))
+      .mutation(({ input, ctx }) => (ctx.app.service.Chain.updateChainTransaction as any)(input, ctx)),
+  });
+
+export type Router = ReturnType<typeof createRouter>;
+export type RouterInput = inferRouterInputs<Router>;
+export type RouterOutput = inferRouterOutputs<Router>;

package/chain/chain.schema.ts

@@ -0,0 +1,67 @@
+import { z, ObjectId, Entity } from '../schema';
+
+export const Chain = Entity.merge(
+  z.object({
+    content: z.string().min(1),
+    type: z
+      .string()
+      .max(100)
+      .min(1),
+    standard: z
+      .string()
+      .max(100)
+      .min(1),
+  })
+);
+
+export const ChainContract = Entity.merge(
+  z.object({
+    chainId: ObjectId,
+    content: z
+      .string()
+      .min(1)
+      .optional(),
+    address: z.string().max(100),
+    type: z
+      .string()
+      .max(100)
+      .min(1),
+    standards: z.array(ObjectId),
+  })
+);
+
+export const ChainToken = Entity.merge(
+  z.object({
+    chainId: ObjectId,
+    chainContractId: ObjectId,
+    address: z.string().max(100), // TODO: validate address?
+    decimals: z.number().optional(),
+    rank: z.number().optional(),
+    description: z.string().optional(),
+    content: z
+      .string()
+      .min(1)
+      .optional(),
+    price: z.number().optional(),
+    hourChange: z.number().optional(),
+    dayChange: z.number().optional(),
+    weekChange: z.number().optional(),
+    marketCap: z.number().optional(),
+    volume: z.number().optional(),
+    symbol: z.string().min(1),
+    circulatingSupply: z.number().optional(),
+    cmcLink: z.string().optional(),
+    movementDown: z.number().optional(),
+    movementUp: z.number().optional(),
+    enteredTop100: z.number().optional(),
+    exitedTop100: z.number().optional(),
+    largeMoveDown: z.number().optional(),
+  })
+);
+
+export const ChainTransaction = Entity.merge(
+  z.object({
+    value: z.string().min(1),
+    chainId: ObjectId,
+  })
+);

package/chain/chain.types.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import * as schema from './chain.schema';
+import { Document, Model } from '@arken/node/mongo';
+
+export type * from './chain.router';
+export type { RouterContext } from '../types';
+
+export type Chain = z.infer<typeof schema.Chain>;
+export type ChainContract = z.infer<typeof schema.ChainContract>;
+export type ChainToken = z.infer<typeof schema.ChainToken>;
+export type ChainTransaction = z.infer<typeof schema.ChainTransaction>;
+
+export type ChainDocument = Chain & Document;
+export type ChainContractDocument = ChainContract & Document;
+export type ChainTokenDocument = ChainToken & Document;
+export type ChainTransactionDocument = ChainTransaction & Document;
+
+export type Mappings = {
+  Chain: Model<ChainDocument>;
+  ChainContract: Model<ChainContractDocument>;
+  ChainToken: Model<ChainTokenDocument>;
+  ChainTransaction: Model<ChainTransactionDocument>;
+};

package/chain/index.ts

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