@arken/node 1.5.1 → 1.5.2

package/db.ts

@@ -11,10 +11,85 @@ import mongoose, {
   Mongoose,
   Query,
 } from 'mongoose';
-import { Model } from './util/mongo';
+import { Model } from './mongo';
 import safeStringify from 'fast-safe-stringify';
 import fsPath from 'path';
 
+import { v4 as uuidv4 } from 'uuid';
+import _ from 'lodash';
+
+
+export function isPostgresError (error: unknown): boolean {
+  if (!error) {
+    return false;
+  }
+
+  return _.every(['severity', 'code', 'detail', 'internalQuery', 'routine'], (attr) => _.has(error as object, attr));
+};
+
+export function isUniqueConstraintViolation (error) { return isPostgresError(error) && error.code === '23505' }
+
+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');
+}
+
+
 let app: any;
 let log: (...msgs: any[]) => void;
 

package/index.ts

@@ -1,18 +1,351 @@
-export * as util from './util';
-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';
+import crypto from 'crypto';
+import { exec } from 'child_process';
+// import jetpack from 'fs-jetpack';
+import * as ethers from 'ethers';
+import _ from 'lodash';
+import config from './config';
+import * as time from './time';
+import * as objects from './object';
+import * as db from './db';
+import * as api from './api';
+import * as guid from './guid';
+import * as number from './number';
+import * as string from './string';
+import * as process2 from './process';
+import * as web3 from './web3';
+import * as math from './math';
+import * as json from './json';
+import * as format from './format';
+import * as rpc from './rpc';
+// import * as browser from './browser';
+
+export * as decoder from './decoder';
+
+const path = require('path');
+const writeLogs = false;
+const logPrefix = process.env.LOG_PREFIX || '[APP]';
+
+export const isDebug =
+  process.env.HOME === '/Users/dev' ||
+  process.env.HOME === '/home/dev' ||
+  process.env.HOME === '/root' ||
+  process.env.LOG === '1';
+
+export function logError(...msgs) {
+  console.log(logPrefix, nowReadable(), ...msgs);
+
+  // const errorLog = jetpack.read(path.resolve('./public/data/errors.json'), 'json') || [];
+
+  // for (const msg of msgs) {
+  //   errorLog.push(JSON.stringify(msg));
+  // }
+
+  if (writeLogs) {
+    // jetpack.write(path.resolve('./public/data/errors.json'), JSON.stringify(errorLog, null, 2), { atomic: true });
+  }
+
+  // console.log(msgs);
+
+  // throw new Error(msgs.join('; '));
+}
+
+export function log(...msgs) {
+  if (isDebug) {
+    console.log(logPrefix, nowReadable(), ...msgs);
+  }
+
+  if (writeLogs) {
+    // const logData = jetpack.read(path.resolve('../public/data/log.json'), 'json') || [];
+    // for (const msg of msgs) {
+    //   logData.push(JSON.stringify(msg));
+    // }
+    // jetpack.write(path.resolve('./public/data/log.json'), JSON.stringify(logData, null, 2));
+  }
+}
+
+export function nowReadable() {
+  return new Date().toISOString().replace(/T/, ' ').replace(/\..+/, '');
+}
+
+export function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function round(num, precision) {
+  const _precision = 10 ** precision;
+  return Math.ceil(num * _precision) / _precision;
+}
+
+export function pad(n, width, z = '0') {
+  const nn = n + '';
+  return nn.length >= width ? nn : new Array(width - nn.length + 1).join(z) + nn;
+}
+
+export function removeDupes(list) {
+  const seen = {};
+  return list.filter(function (item) {
+    const k1 = item.seller + item.tokenId + item.blockNumber;
+    const k2 = item.id;
+    const exists = seen.hasOwnProperty(k1) || seen.hasOwnProperty(k2);
+
+    if (!exists) {
+      seen[k1] = true;
+      seen[k2] = true;
+    }
+
+    return !exists;
+  });
+}
+
+export const toLong = (x, decimals = 16) =>
+  decimals === 16 ? ethers.utils.parseEther(x + '') : ethers.utils.parseUnits(x + '', decimals);
+export const toShort = (x) => round(parseFloat(ethers.utils.formatEther(x)), 4);
+
+let updatingGit = false;
+
+export async function updateGit() {
+  if (updatingGit) return;
+
+  updatingGit = true;
+  try {
+    const execPromise = require('util').promisify(exec);
+
+    try {
+      await execPromise('rm ./db/.git/index.lock');
+    } catch (e2) {}
+
+    const { stdout, stderr } = await execPromise(
+      'cd db && git add -A && git commit -m "build: Binzy doz it" && git push --set-upstream origin master'
+    );
+
+    console.log(stderr, stdout);
+
+    await wait(100);
+  } catch (e) {
+    console.log(e);
+  }
+
+  updatingGit = false;
+}
+
+export function groupBySub(xs, key, subkey) {
+  return (
+    xs.reduce(function (rv, x) {
+      if (!x[key][subkey]) return rv;
+      (rv[x[key][subkey]] = rv[x[key][subkey]] || []).push(x);
+      return rv;
+    }, {}) || null
+  );
+}
+
+export function groupBy(xs, key) {
+  return (
+    xs.reduce(function (rv, x) {
+      if (!x[key]) return rv;
+      (rv[x[key]] = rv[x[key]] || []).push(x);
+      return rv;
+    }, {}) || null
+  );
+}
+
+export function getHighestId(arr) {
+  let highest = 0;
+
+  for (const item of arr) {
+    if (item.id > highest) {
+      highest = item.id;
+    }
+  }
+
+  return highest;
+}
+
+export function average(arr) {
+  return arr.reduce((p, c) => p + c, 0) / arr.length;
+}
+
+export function ordinalise(n) {
+  return (
+    n +
+    (n % 10 == 1 && n % 100 != 11
+      ? 'st'
+      : n % 10 == 2 && n % 100 != 12
+      ? 'nd'
+      : n % 10 == 3 && n % 100 != 13
+      ? 'rd'
+      : 'th')
+  );
+}
+export function commarise(n) {
+  return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+export function getTime() {
+  return new Date().getTime();
+}
+
+export const capitalizeFirstLetters = (text?: string) => text != null && _.startCase(text?.toLowerCase());
+
+export function convertToDecimal(byte) {
+  let result = 0;
+
+  byte = byte.split('');
+
+  byte.reverse();
+
+  for (let a = 0; a < byte.length; a++) {
+    if (byte[a] === '1') {
+      result += 2 ** a;
+    }
+  }
+
+  return result;
+}
+
+export const phoneMask = (phone: string) => {
+  //This regular expression provides the pattern for a phone number in format 000-000-0000
+  const x = phone.replace(/\D/g, '').match(/(\d{0,3})(\d{0,3})(\d{0,4})/);
+  return !x[2] ? x[1] : x[1] + '-' + x[2] + (x[3] ? '-' + x[3] : '');
+};
+
+export function binaryAgent(str) {
+  let bytes = str.split(' ');
+  let output = '';
+
+  for (let k = 0; k < bytes.length; k++) {
+    if (bytes[k]) output += String.fromCharCode(convertToDecimal(bytes[k]));
+  }
+
+  return output;
+}
+
+export function decodePayload(msg) {
+  try {
+    if (typeof msg === 'object') return msg;
+
+    // @ts-ignore
+    let json = binaryAgent(msg); //String.fromCharCode.apply(null, new Uint8Array(msg));
+    // else if (Buffer.isBuffer(msg)) json = msg.toString();
+
+    // explicitly decode the String as UTF-8 for Unicode
+    //   https://github.com/mathiasbynens/utf8.js
+    // json = utf8.decode(json)
+    // const buffer = Buffer.from(json, "binary");
+    if (typeof json === 'string') return JSON.parse(json);
+
+    return json;
+  } catch (err) {
+    // ...
+    console.log(err, msg);
+  }
+}
+
+export function isNumeric(str) {
+  if (typeof str != 'string') return false; // we only process strings!
+  return (
+    // @ts-ignore
+    !isNaN(str) && // use type coercion to parse the _entirety_ of the string (`parseFloat` alone does not do this)...
+    !isNaN(parseFloat(str))
+  ); // ...and ensure strings of whitespace fail
+}
+
+/**
+ * Wrapper around fetch with an optional timeout
+ * @param {Url} url
+ * @param {Request} request
+ * @param {number} timeout
+ */
+async function fetchWithTimeout(url, request, timeout) {
+  return Promise.race([
+    fetch(url, request),
+    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), timeout)),
+  ]);
+}
+
+export function sha256(str) {
+  return crypto.createHash('sha256').update(str, 'utf8').digest('base64');
+}
+
+// /**
+//  * sha256 encodes a given string message
+//  * @param {string} message
+//  * Borrowed from
+//  * https://developers.cloudflare.com/workers/examples/cache-api
+//  */
+// async function sha256(message) {
+//   // encode as UTF-8
+//   const msgBuffer = new TextEncoder().encode(message)
+//   // hash the message
+//   const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer)
+//   // convert ArrayBuffer to Array
+//   const hashArray = Array.from(new Uint8Array(hashBuffer))
+//   // convert bytes to hex string
+//   const hashHex = hashArray.map(b => ("00" + b.toString(16)).slice(-2)).join("")
+//   return hashHex
+// }
+
+export function randomPosition(min, max) {
+  return Math.random() * (max - min) + min;
+}
+
+export function shuffleArray(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+
+  return array;
+}
+
+export const getAddress = (address) => {
+  const mainNetChainId = 56;
+  const chainId = window?.location?.hostname === 'testnet.arken.gg' ? 97 : process.env.REACT_APP_CHAIN_ID;
+  return address[chainId] ? address[chainId] : address[mainNetChainId];
+};
+
+export function random(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+export const isEthereumAddress = (address: string) => {
+  // Regular expression to check if the string is a valid Ethereum address
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+};
+
+export const ipHashFromSocket = (socket) => {
+  const ip = socket.handshake.headers['x-forwarded-for']?.split(',')[0] || socket.conn.remoteAddress?.split(':')[3];
+  let hash = ip ? sha256(ip.slice(ip.length / 2)) : '';
+  hash = ip ? hash.slice(hash.length - 10, hash.length - 1) : '';
+
+  return hash;
+};
+
+export * as physics from './physics';
+export * as number from './number';
+export * as object from './object';
+export * as api from './api';
+export * as string from './string';
+export * as web3 from './web3';
+export * as math from './math';
+export * as db from './db';
+export * as time from './time';
+export * as config from './config';
+export * as rpc from './rpc';
+
+export default {
+  objects,
+  api,
+  guid,
+  number,
+  string,
+  process: process2,
+  web3,
+  math,
+  json,
+  db,
+  format,
+  rpc,
+  // browser,
+  config,
+  time,
+};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@arken/node",
-  "version": "1.5.1",
+  "version": "1.5.2",
   "description": "",
-  "main": "index.ts",
-  "types": "types.ts",
+  "main": "build/index.js",
+  "types": "build/types.d.ts",
   "scripts": {
     "build": "npm-run-all dist",
     "clean": "del-cli ./build && make-dir ./build",

package/tsconfig.json

@@ -44,8 +44,39 @@
     "components/**/*",
     "hooks/**/*",
     "generated/**/*",
-    "util/**/*",
-    "util/types/mongo.d.ts",
+    "trpc/**/*",
+    "types/**/*",
+    "web3/**/*",
+    "./api.ts",
+    "./array.ts",
+    "./browser.ts",
+    "./codebase.ts",
+    "./db.ts",
+    "./decoder.ts",
+    "./format.ts",
+    "./guid.ts",
+    "./json.ts",
+    "./log.ts",
+    "./math.ts",
+    "./merkle.ts",
+    "./mongo.ts",
+    "./number.ts",
+    "./object.ts",
+    "./otp.ts",
+    "./physics.ts",
+    "./process.ts",
+    "./router.ts",
+    "./rpc.ts",
+    "./schema.ts",
+    "./seer.ts",
+    "./string.ts",
+    "./text.ts",
+    "./types.ts",
+    "./util.ts",
+    "./web3.ts",
+    "./websocket.ts",
+    "./zk.ts",
+    "./zod.ts",
     "legacy/**/*.json",
     "contracts/**/*.json",
     "generated/**/*.json"

package/util.ts

@@ -0,0 +1 @@
+export * from '.';

package/modules/area/area.models.ts

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

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

@@ -1,22 +0,0 @@
-// 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({}));