@arken/node 1.5.1 → 1.5.3

package/modules/video/video.service.ts

@@ -1,274 +0,0 @@
-import type {
-  Video,
-  VideoParticipant,
-  VideoDialogue,
-  VideoTranscript,
-  VideoScene,
-  RouterContext,
-  Router,
-  RouterInput,
-  RouterOutput,
-} from './video.types';
-import { getFilter } from '../../util/api';
-
-export class Service {
-  async getVideo(input: RouterInput['getVideo'], ctx: RouterContext): Promise<RouterOutput['getVideo']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.getVideo', input.query);
-
-    const filter = getFilter(input.query);
-    const video = await ctx.app.model.Video.findOne(filter).lean().exec();
-    if (!video) throw new Error('Video not found');
-
-    return video as Video;
-  }
-
-  async createVideo(input: RouterInput['createVideo'], ctx: RouterContext): Promise<RouterOutput['createVideo']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.createVideo', input.data);
-
-    const video = await ctx.app.model.Video.create(input.data);
-    return video as Video;
-  }
-
-  async updateVideo(input: RouterInput['updateVideo'], ctx: RouterContext): Promise<RouterOutput['updateVideo']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.updateVideo', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedVideo = await ctx.app.model.Video.findOneAndUpdate(filter, input.data, { new: true }).lean().exec();
-    if (!updatedVideo) throw new Error('Video update failed');
-
-    return updatedVideo as Video;
-  }
-
-  async deleteVideo(input: RouterInput['deleteVideo'], ctx: RouterContext): Promise<RouterOutput['deleteVideo']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.deleteVideo', input.query);
-
-    const filter = getFilter(input.query);
-    const video = await ctx.app.model.Video.findOneAndDelete(filter).lean().exec();
-    if (!video) throw new Error('Video not found');
-
-    return video as Video;
-  }
-
-  // Similar changes for VideoParticipant, VideoDialogue, VideoTranscript, VideoScene...
-
-  async getVideoParticipant(
-    input: RouterInput['getVideoParticipant'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getVideoParticipant']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.getVideoParticipant', input.query);
-
-    const filter = getFilter(input.query);
-    const participant = await ctx.app.model.VideoParticipant.findOne(filter).lean().exec();
-    if (!participant) throw new Error('VideoParticipant not found');
-
-    return participant as VideoParticipant;
-  }
-
-  async createVideoParticipant(
-    input: RouterInput['createVideoParticipant'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createVideoParticipant']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.createVideoParticipant', input.data);
-
-    const participant = await ctx.app.model.VideoParticipant.create(input.data);
-    return participant as VideoParticipant;
-  }
-
-  async updateVideoParticipant(
-    input: RouterInput['updateVideoParticipant'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateVideoParticipant']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.updateVideoParticipant', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedParticipant = await ctx.app.model.VideoParticipant.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedParticipant) throw new Error('VideoParticipant update failed');
-
-    return updatedParticipant as VideoParticipant;
-  }
-
-  async deleteVideoParticipant(
-    input: RouterInput['deleteVideoParticipant'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteVideoParticipant']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.deleteVideoParticipant', input.query);
-
-    const filter = getFilter(input.query);
-    const participant = await ctx.app.model.VideoParticipant.findOneAndDelete(filter).lean().exec();
-    if (!participant) throw new Error('VideoParticipant not found');
-
-    return participant as VideoParticipant;
-  }
-
-  async getVideoDialogue(
-    input: RouterInput['getVideoDialogue'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getVideoDialogue']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.getVideoDialogue', input.query);
-
-    const filter = getFilter(input.query);
-    const dialogue = await ctx.app.model.VideoDialogue.findOne(filter).lean().exec();
-    if (!dialogue) throw new Error('VideoDialogue not found');
-
-    return dialogue as VideoDialogue;
-  }
-
-  async createVideoDialogue(
-    input: RouterInput['createVideoDialogue'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createVideoDialogue']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.createVideoDialogue', input.data);
-
-    const dialogue = await ctx.app.model.VideoDialogue.create(input.data);
-    return dialogue as VideoDialogue;
-  }
-
-  async updateVideoDialogue(
-    input: RouterInput['updateVideoDialogue'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateVideoDialogue']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.updateVideoDialogue', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedDialogue = await ctx.app.model.VideoDialogue.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedDialogue) throw new Error('VideoDialogue update failed');
-
-    return updatedDialogue as VideoDialogue;
-  }
-
-  async deleteVideoDialogue(
-    input: RouterInput['deleteVideoDialogue'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteVideoDialogue']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.deleteVideoDialogue', input.query);
-
-    const filter = getFilter(input.query);
-    const dialogue = await ctx.app.model.VideoDialogue.findOneAndDelete(filter).lean().exec();
-    if (!dialogue) throw new Error('VideoDialogue not found');
-
-    return dialogue as VideoDialogue;
-  }
-
-  async getVideoTranscript(
-    input: RouterInput['getVideoTranscript'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getVideoTranscript']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.getVideoTranscript', input.query);
-
-    const filter = getFilter(input.query);
-    const transcript = await ctx.app.model.VideoTranscript.findOne(filter).lean().exec();
-    if (!transcript) throw new Error('VideoTranscript not found');
-
-    return transcript as VideoTranscript;
-  }
-
-  async createVideoTranscript(
-    input: RouterInput['createVideoTranscript'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createVideoTranscript']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.createVideoTranscript', input.data);
-
-    const transcript = await ctx.app.model.VideoTranscript.create(input.data);
-    return transcript as VideoTranscript;
-  }
-
-  async updateVideoTranscript(
-    input: RouterInput['updateVideoTranscript'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateVideoTranscript']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.updateVideoTranscript', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedTranscript = await ctx.app.model.VideoTranscript.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedTranscript) throw new Error('VideoTranscript update failed');
-
-    return updatedTranscript as VideoTranscript;
-  }
-
-  async deleteVideoTranscript(
-    input: RouterInput['deleteVideoTranscript'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteVideoTranscript']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.deleteVideoTranscript', input.query);
-
-    const filter = getFilter(input.query);
-    const transcript = await ctx.app.model.VideoTranscript.findOneAndDelete(filter).lean().exec();
-    if (!transcript) throw new Error('VideoTranscript not found');
-
-    return transcript as VideoTranscript;
-  }
-
-  async getVideoScene(input: RouterInput['getVideoScene'], ctx: RouterContext): Promise<RouterOutput['getVideoScene']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.getVideoScene', input.query);
-
-    const filter = getFilter(input.query);
-    const scene = await ctx.app.model.VideoScene.findOne(filter).lean().exec();
-    if (!scene) throw new Error('VideoScene not found');
-
-    return scene as VideoScene;
-  }
-
-  async createVideoScene(
-    input: RouterInput['createVideoScene'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createVideoScene']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.createVideoScene', input.data);
-
-    const scene = await ctx.app.model.VideoScene.create(input.data);
-    return scene as VideoScene;
-  }
-
-  async updateVideoScene(
-    input: RouterInput['updateVideoScene'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateVideoScene']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.updateVideoScene', input.query, input.data);
-
-    const filter = getFilter(input.query);
-    const updatedScene = await ctx.app.model.VideoScene.findOneAndUpdate(filter, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedScene) throw new Error('VideoScene update failed');
-
-    return updatedScene as VideoScene;
-  }
-
-  async deleteVideoScene(
-    input: RouterInput['deleteVideoScene'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['deleteVideoScene']> {
-    if (!input) throw new Error('Input should not be void');
-    console.log('Video.Service.deleteVideoScene', input.query);
-
-    const filter = getFilter(input.query);
-    const scene = await ctx.app.model.VideoScene.findOneAndDelete(filter).lean().exec();
-    if (!scene) throw new Error('VideoScene not found');
-
-    return scene as VideoScene;
-  }
-}

package/modules/video/video.types.ts

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-import * as schema from './video.schema';
-import { Document, Model } from '../../util/mongo';
-import type { RouterContext } from '../../types';
-import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import type { Router } from './video.router';
-
-export type * from './video.router';
-export type * from './video.service';
-export type { RouterContext };
-
-export type Video = z.infer<typeof schema.Video>;
-export type VideoParticipant = z.infer<typeof schema.VideoParticipant>;
-export type VideoDialogue = z.infer<typeof schema.VideoDialogue>;
-export type VideoTranscript = z.infer<typeof schema.VideoTranscript>;
-export type VideoScene = z.infer<typeof schema.VideoScene>;
-
-export type VideoDocument = Video & Document;
-export type VideoParticipantDocument = VideoParticipant & Document;
-export type VideoDialogueDocument = VideoDialogue & Document;
-export type VideoTranscriptDocument = VideoTranscript & Document;
-export type VideoSceneDocument = VideoScene & Document;
-
-export type Mappings = {
-  Video: Model<VideoDocument>;
-  VideoParticipant: Model<VideoParticipantDocument>;
-  VideoDialogue: Model<VideoDialogueDocument>;
-  VideoTranscript: Model<VideoTranscriptDocument>;
-  VideoScene: Model<VideoSceneDocument>;
-};
-
-export type RouterInput = inferRouterInputs<Router>;
-export type RouterOutput = inferRouterOutputs<Router>;

package/router.ts

@@ -1,49 +0,0 @@
-import zod from 'zod';
-import { initTRPC, TRPCError } from '@trpc/server';
-import type { RouterContext } from './types';
-import * as Area from './modules/area/area.router';
-import * as Asset from './modules/asset/asset.router';
-import * as Chain from './modules/chain/chain.router';
-import * as Character from './modules/character/character.router';
-import * as Chat from './modules/chat/chat.router';
-import * as Collection from './modules/collection/collection.router';
-import * as Core from './modules/core/core.router';
-import * as Game from './modules/game/game.router';
-import * as Interface from './modules/interface/interface.router';
-import * as Item from './modules/item/item.router';
-import * as Job from './modules/job/job.router';
-import * as Market from './modules/market/market.router';
-import * as Product from './modules/product/product.router';
-import * as Profile from './modules/profile/profile.router';
-import * as Raffle from './modules/raffle/raffle.router';
-import * as Skill from './modules/skill/skill.router';
-import * as Video from './modules/video/video.router';
-
-export const z = zod;
-export const t = initTRPC.context<RouterContext>().create();
-export const router = t.router;
-export const procedure = t.procedure;
-export const createCallerFactory = t.createCallerFactory;
-
-export const createRouter = () =>
-  router({
-    area: Area.createRouter(),
-    asset: Asset.createRouter(),
-    chain: Chain.createRouter(),
-    character: Character.createRouter(),
-    chat: Chat.createRouter(),
-    collection: Collection.createRouter(),
-    core: Core.createRouter(),
-    game: Game.createRouter(),
-    interface: Interface.createRouter(),
-    item: Item.createRouter(),
-    job: Job.createRouter(),
-    market: Market.createRouter(),
-    product: Product.createRouter(),
-    profile: Profile.createRouter(),
-    raffle: Raffle.createRouter(),
-    skill: Skill.createRouter(),
-    video: Video.createRouter(),
-  });
-
-export type Router = ReturnType<typeof createRouter>;

package/types.ts

@@ -1,183 +0,0 @@
-// arken/packages/node/types.ts
-//
-import { createRouter } from './router';
-
-export * as util from './util';
-
-// Imports
-import * as Area from './modules/area';
-import * as Asset from './modules/asset';
-import * as Chain from './modules/chain';
-import * as Character from './modules/character';
-import * as Chat from './modules/chat';
-import * as Collection from './modules/collection';
-import * as Core from './modules/core';
-import * as Game from './modules/game';
-import * as Interface from './modules/interface';
-import * as Item from './modules/item';
-import * as Job from './modules/job';
-import * as Market from './modules/market';
-import * as Product from './modules/product';
-import * as Profile from './modules/profile';
-import * as Raffle from './modules/raffle';
-import * as Skill from './modules/skill';
-import * as Video from './modules/video';
-
-// Exports
-export * as Area from './modules/area';
-export * as Asset from './modules/asset';
-export * as Chain from './modules/chain';
-export * as Character from './modules/character';
-export * as Chat from './modules/chat';
-export * as Collection from './modules/collection';
-export * as Core from './modules/core';
-export * as Game from './modules/game';
-export * as Interface from './modules/interface';
-export * as Item from './modules/item';
-export * as Job from './modules/job';
-export * as Market from './modules/market';
-export * as Product from './modules/product';
-export * as Profile from './modules/profile';
-export * as Raffle from './modules/raffle';
-export * as Skill from './modules/skill';
-export * as Video from './modules/video';
-
-export type * as Schema from './schema';
-
-export type Router = ReturnType<typeof createRouter>;
-
-export type ApplicationServiceType = Partial<{
-  Area: Area.Service;
-  Asset: Asset.Service;
-  Chain: Chain.Service;
-  Character: Character.Service;
-  Chat: Chat.Service;
-  Collection: Collection.Service;
-  Core: Core.Service;
-  Game: Game.Service;
-  Interface: Interface.Service;
-  Item: Item.Service;
-  Job: Job.Service;
-  Market: Market.Service;
-  Product: Product.Service;
-  Profile: Profile.Service;
-  Raffle: Raffle.Service;
-  Skill: Skill.Service;
-  Video: Video.Service;
-}>;
-
-export type ApplicationModelType = Partial<
-  Area.Types.Mappings &
-    Asset.Types.Mappings &
-    Chain.Types.Mappings &
-    Character.Types.Mappings &
-    Chat.Types.Mappings &
-    Collection.Types.Mappings &
-    Core.Types.Mappings &
-    Game.Types.Mappings &
-    Interface.Types.Mappings &
-    Item.Types.Mappings &
-    Job.Types.Mappings &
-    Market.Types.Mappings &
-    Product.Types.Mappings &
-    Profile.Types.Mappings &
-    Raffle.Types.Mappings &
-    Skill.Types.Mappings &
-    Video.Types.Mappings
->;
-
-export interface Application {
-  model: ApplicationModelType;
-  service: ApplicationServiceType;
-  web3?: any;
-}
-
-export type RouterClient = {
-  socket: any;
-  roles: string[];
-  permissions: any;
-  profile?: Profile.Types.Profile;
-  emit: any;
-};
-
-export type RouterContext = {
-  app: Application;
-  client?: RouterClient;
-  profile?: Profile.Types.Profile;
-};
-
-export interface Signature {
-  hash?: string;
-  address?: string;
-}
-
-export type Position = {
-  x: number;
-  y: number;
-  z?: number;
-};
-
-export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
-
-export type PatchOp =
-  | { op: 'set'; key: string; value: any }
-  | { op: 'unset'; key: string }
-  | { op: 'inc'; key: string; value: number }
-  | { op: 'push'; key: string; value: any }
-  | { op: 'merge'; key: string; value: Record<string, any> };
-
-export type EntityPatch = {
-  entityType: string; // allow any string
-  entityId: string;
-  baseVersion?: number;
-  ops: PatchOp[];
-  claimable?: boolean;
-};
-
-export type GameObjectDef = {
-  id: string;
-  type: string; // allow any string
-  name: string;
-  position: { x: number; y: number };
-  radius?: number; // interaction distance
-  tags?: string[];
-  meta?: Record<string, any>;
-};
-
-export type Requirement =
-  | { kind: 'exists'; key: string }
-  | { kind: 'touchedObject'; objectId: string; afterKey?: string; writeKey: string };
-
-// Generic effects (can be positive or negative)
-export type Effect =
-  | { kind: 'item.grant'; itemKey: string; quantity?: number }
-  | { kind: 'currency.grant'; key: string; amount: number } // negative amount allowed
-  | { kind: 'reputation.delta'; npcId: string; amount: number } // negative allowed
-  | { kind: 'state.patch'; patch: EntityPatch } // generic patch against any entityType
-  | { kind: 'ui.unlock'; uiKey: string } // optional, future
-  | { kind: 'emit'; eventType: string; payload?: any }; // optional, future
-
-export type QuestDef = {
-  id: string;
-  metaverseId: string;
-  name: string;
-
-  // Requirements can be checked shard-side (for anti-cheat) AND client-side (for UI state)
-  requirements: Requirement[];
-
-  // Effects are applied on completion/claim (seer-side)
-  effects: Effect[];
-
-  // keys shard will write (auditing + permissions)
-  writes?: string[];
-};
-
-type QuestCompleteOp = {
-  kind: 'quest.complete';
-  id: string;
-  ts: number;
-  questId: string;
-  metaverseId: string;
-  evidence?: Record<string, any>;
-  effects?: any[]; // can include effect refs for replay/debug
-};

package/util/db/index.ts

@@ -1,7 +0,0 @@
-import isPostgresError from './isPostgresError'
-import isUniqueConstraintViolation from './isUniqueConstraintViolation'
-
-export default {
-  isPostgresError,
-  isUniqueConstraintViolation,
-}

package/util/db/isPostgresError.ts

@@ -1,9 +0,0 @@
-import _ from 'lodash';
-
-export default (error: unknown): boolean => {
-  if (!error) {
-    return false;
-  }
-
-  return _.every(['severity', 'code', 'detail', 'internalQuery', 'routine'], (attr) => _.has(error as object, attr));
-};

package/util/db/isUniqueConstraintViolation.ts

@@ -1,3 +0,0 @@
-import isPostgresError from './isPostgresError'
-
-export default (error) => isPostgresError(error) && error.code === '23505'

package/util/db.ts

@@ -1,62 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import _ from 'lodash';
-
-export function generateLongId(): string {
-  return uuidv4().toUpperCase();
-}
-
-export function generateShortId() {
-  const timestamp = ((new Date().getTime() / 1000) | 0).toString(16);
-  return timestamp + 'xxxxxxxxxxxxxxxx'.replace(/[x]/g, () => ((Math.random() * 16) | 0).toString(16)).toLowerCase();
-}
-
-export const uuidFormat = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
-
-export function generateLongId2(): string {
-  return uuidFormat
-    .replace(/[xy]/g, (c) => {
-      const r = (Math.random() * 16) | 0;
-      const v = c === 'x' ? r : (r & 0x3) | 0x8;
-      return v.toString(16);
-    })
-    .toUpperCase();
-}
-
-export function decodeRequest(data: any): any {
-  if (
-    data === undefined ||
-    data === null ||
-    typeof data === 'string' ||
-    typeof data === 'number' ||
-    typeof data === 'boolean'
-  )
-    return data;
-
-  if (Array.isArray(data)) {
-    return data.map(decodeRequest);
-  }
-
-  if (typeof data !== 'object') return data;
-
-  const res: any = {};
-
-  for (const key in data) {
-    if (key === 'set') {
-      return data[key];
-    } else if (['create', 'connectOrCreate', 'upsert'].includes(key)) {
-      return decodeRequest(data[key]);
-    } else {
-      res[key] = decodeRequest(data[key]);
-    }
-  }
-
-  return Object.keys(res).length === 0 ? null : res;
-}
-
-export function escapeStringRegexp(string: string): string {
-  if (typeof string !== 'string') {
-    throw new TypeError('Expected a string');
-  }
-
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
-}