@arken/node 1.5.1 → 1.5.2

package/modules/area/area.service.ts

@@ -1,124 +0,0 @@
-import type { Area, AreaLandmark, AreaType, RouterInput, RouterOutput, RouterContext } from './area.types';
-import { getFilter } from '../../util/api';
-import { ARXError } from '../../util/rpc';
-
-export class Service {
-  async getArea(input: RouterInput['getArea'], ctx: RouterContext): Promise<RouterOutput['getArea']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.getArea', input);
-
-    const filter = getFilter(input);
-    // @ts-ignore
-    const area = await ctx.app.model.Area.findOne(filter).asJSON();
-    if (!area) throw new Error('Area not found');
-
-    return area as Area;
-  }
-
-  async getAreas(input: RouterInput['getAreas'], ctx: RouterContext): Promise<RouterOutput['getAreas']> {
-    if (!input) throw new ARXError('NO_INPUT');
-
-    const filter = getFilter(input);
-
-    const limit = input.limit ?? 50;
-    const skip = input.skip ?? 0;
-
-    const [items, total] = await Promise.all([
-      // @ts-ignore
-      ctx.app.model.Area.find(filter).skip(skip).limit(limit).asJSON(),
-      ctx.app.model.Area.find(filter).countDocuments().exec(),
-    ]);
-
-    return { items, total };
-  }
-
-  async getAreaLandmark(
-    input: RouterInput['getAreaLandmark'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getAreaLandmark']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.getAreaLandmark', input.query);
-
-    const filter = getFilter(input.query);
-    const areaLandmark = await ctx.app.model.AreaLandmark.findOne(filter).lean().exec();
-    if (!areaLandmark) throw new Error('AreaLandmark not found');
-
-    return areaLandmark as AreaLandmark;
-  }
-
-  async getAreaType(input: RouterInput['getAreaType'], ctx: RouterContext): Promise<RouterOutput['getAreaType']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.getAreaType', input.query);
-
-    const filter = getFilter(input.query);
-    const areaType = await ctx.app.model.AreaType.findOne(filter).lean().exec();
-    if (!areaType) throw new Error('AreaType not found');
-
-    return areaType as AreaType;
-  }
-
-  async saveArea(input: RouterInput['saveArea'], ctx: RouterContext): Promise<RouterOutput['saveArea']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.saveArea', input);
-
-    const filter = getFilter(input);
-    const area = await ctx.app.model.Area.findOneAndUpdate(filter, input.data, { new: true }).lean().exec();
-    if (!area) throw new Error('Area update failed');
-
-    return area as Area;
-  }
-
-  async createAreaLandmark(
-    input: RouterInput['createAreaLandmark'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createAreaLandmark']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.createAreaLandmark', input.data);
-
-    const areaLandmark = await ctx.app.model.AreaLandmark.create(input.data);
-    return areaLandmark as AreaLandmark;
-  }
-
-  async createAreaType(
-    input: RouterInput['createAreaType'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createAreaType']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.createAreaType', input.data);
-
-    const areaType = await ctx.app.model.AreaType.create(input.data);
-    return areaType as AreaType;
-  }
-
-  async updateAreaLandmark(
-    input: RouterInput['updateAreaLandmark'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateAreaLandmark']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.updateAreaLandmark', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedAreaLandmark = await ctx.app.model.AreaLandmark.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAreaLandmark) throw new Error('AreaLandmark update failed');
-
-    return updatedAreaLandmark as AreaLandmark;
-  }
-
-  async updateAreaType(
-    input: RouterInput['updateAreaType'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateAreaType']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Area.Service.updateAreaType', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedAreaType = await ctx.app.model.AreaType.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAreaType) throw new Error('AreaType update failed');
-
-    return updatedAreaType as AreaType;
-  }
-}

package/modules/area/area.types.ts

@@ -1,26 +0,0 @@
-import { z } from 'zod';
-import * as schema from './area.schema';
-import { Document, Model } from '../../util/mongo';
-
-export type * from './area.router';
-export type * from './area.service';
-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/modules/area/index.ts

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

package/modules/asset/asset.models.ts

@@ -1,59 +0,0 @@
-import * as mongo from '../../util/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/modules/asset/asset.router.ts

@@ -1,55 +0,0 @@
-// module/asset.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 { 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/modules/asset/asset.schema.ts

@@ -1,27 +0,0 @@
-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/modules/asset/asset.service.ts

@@ -1,85 +0,0 @@
-import type { Asset, AssetLicense, Router, RouterInput, RouterOutput, RouterContext } from './asset.types';
-
-export class Service {
-  async getAsset(input: RouterInput['getAsset'], ctx: RouterContext): Promise<RouterOutput['getAsset']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.getAsset', input.assetId);
-
-    const asset = await ctx.app.model.Asset.findById(input.assetId).lean().exec();
-    if (!asset) throw new Error('Asset not found');
-
-    return asset as Asset;
-  }
-
-  async getAssetLicense(
-    input: RouterInput['getAssetLicense'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getAssetLicense']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.getAssetLicense', input.assetLicenseId);
-
-    const assetLicense = await ctx.app.model.AssetLicense.findById(input.assetLicenseId).lean().exec();
-    if (!assetLicense) throw new Error('AssetLicense not found');
-
-    return assetLicense as AssetLicense;
-  }
-
-  async createAsset(input: RouterInput['createAsset'], ctx: RouterContext): Promise<RouterOutput['createAsset']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.createAsset', input.uri, input.type);
-
-    const asset = await ctx.app.model.Asset.create({
-      uri: input.uri,
-      type: input.type,
-      standards: input.standards,
-      licenseId: input.licenseId,
-      chainId: input.chainId,
-    });
-
-    return asset as Asset;
-  }
-
-  async createAssetLicense(
-    input: RouterInput['createAssetLicense'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createAssetLicense']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.createAssetLicense', input.value);
-
-    const assetLicense = await ctx.app.model.AssetLicense.create({
-      value: input.value,
-      assets: input.assets,
-    });
-
-    return assetLicense as AssetLicense;
-  }
-
-  async updateAsset(input: RouterInput['updateAsset'], ctx: RouterContext): Promise<RouterOutput['updateAsset']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.updateAsset', input.assetId, input.data);
-
-    const updatedAsset = await ctx.app.model.Asset.findByIdAndUpdate(input.assetId, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAsset) throw new Error('Asset update failed');
-
-    return updatedAsset as Asset;
-  }
-
-  async updateAssetLicense(
-    input: RouterInput['updateAssetLicense'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateAssetLicense']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Asset.Service.updateAssetLicense', input.assetLicenseId, input.data);
-
-    const updatedAssetLicense = await ctx.app.model.AssetLicense.findByIdAndUpdate(input.assetLicenseId, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedAssetLicense) throw new Error('AssetLicense update failed');
-
-    return updatedAssetLicense as AssetLicense;
-  }
-}

package/modules/asset/asset.types.ts

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import * as schema from './asset.schema';
-import { Document, Model } from '../../util/mongo';
-
-export type * from './asset.router';
-export type * from './asset.service';
-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/modules/asset/index.ts

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

package/modules/chain/chain.models.ts

@@ -1,50 +0,0 @@
-import * as mongo from '../../util/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/modules/chain/chain.router.ts

@@ -1,104 +0,0 @@
-// module/chain.router.ts
-
-import { z as zod } from 'zod';
-import { initTRPC, inferRouterInputs } from '@trpc/server';
-import { customErrorFormatter, hasRole } from '../../util/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/modules/chain/chain.schema.ts

@@ -1,52 +0,0 @@
-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,
-  })
-);