@akanjs/base 0.0.1

package/README.md

@@ -0,0 +1,11 @@
+# akan
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build akan` to build the library.
+
+## Running unit tests
+
+Run `nx test akan` to execute the unit tests via [Jest](https://jestjs.io).

package/index.ts

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@akanjs/base",
+  "version": "0.0.1",
+  "type": "module"
+}

package/project.json

@@ -0,0 +1,23 @@
+{
+  "name": "@akanjs/base",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "pkgs/@akanjs/base",
+  "projectType": "application",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/{projectRoot}",
+        "main": "{projectRoot}/index.ts",
+        "tsConfig": "{projectRoot}/tsconfig.json",
+        "format": ["esm"],
+        "declaration": true,
+        "bundle": false,
+        "generatePackageJson": true
+      }
+    },
+    "lint": { "executor": "@nx/eslint:lint" }
+  }
+}

package/src/base.ts

@@ -0,0 +1,145 @@
+export class Enum<T> {
+  readonly value: T; // for type
+  readonly valueMap: Map<T, number>;
+  constructor(readonly values: T[]) {
+    this.valueMap = new Map(values.map((value, idx) => [value, idx] as [T, number]));
+  }
+  has(value: T): boolean {
+    return this.valueMap.has(value);
+  }
+  indexOf(value: T): number {
+    const idx = this.valueMap.get(value);
+    if (idx === undefined) throw new Error(`Value ${value} is not in enum`);
+    return idx;
+  }
+  find(callback: (value: T, index: number, array: T[]) => boolean): T {
+    const val = this.values.find(callback);
+    if (val === undefined) throw new Error(`Value not found in enum`);
+    return val;
+  }
+  findIndex(callback: (value: T, index: number, array: T[]) => boolean): number {
+    const idx = this.values.findIndex(callback);
+    if (idx === -1) throw new Error(`Value not found in enum`);
+    return idx;
+  }
+  filter(callback: (value: T, index: number, array: T[]) => boolean): T[] {
+    return this.values.filter(callback);
+  }
+  map<R>(callback: (value: T, index: number, array: T[]) => R): R[] {
+    return this.values.map(callback);
+  }
+  forEach(callback: (value: T, index: number, array: T[]) => void): void {
+    this.values.forEach(callback);
+  }
+}
+export const enumOf = <T>(values: T[]) => new Enum(values);
+export type EnumType<E> = E extends Enum<infer T> ? T : never;
+
+export class DataList<Light extends { id: string }> {
+  // [immerable] = true;
+  #idMap: Map<string, number>;
+  length: number;
+  values: Light[];
+  constructor(data: Light[] | DataList<Light> = []) {
+    this.values = Array.isArray(data) ? [...data] : [...data.values];
+    this.#idMap = new Map(this.values.map((value, idx) => [value.id, idx]));
+    this.length = this.values.length;
+  }
+  indexOf(id: string) {
+    const idx = this.#idMap.get(id);
+    if (idx === undefined) throw new Error(`Value ${id} is not in list`);
+    return idx;
+  }
+  set(value: Light) {
+    const idx = this.#idMap.get(value.id);
+    if (idx !== undefined) this.values = [...this.values.slice(0, idx), value, ...this.values.slice(idx + 1)];
+    else {
+      this.#idMap.set(value.id, this.length);
+      this.values = [...this.values, value];
+      this.length++;
+    }
+    return this;
+  }
+  delete(id: string) {
+    const idx = this.#idMap.get(id);
+    if (idx === undefined) return this;
+    this.#idMap.delete(id);
+    this.values.splice(idx, 1);
+    this.values.slice(idx).forEach((value, i) => this.#idMap.set(value.id, i + idx));
+    this.length--;
+    return this;
+  }
+  get(id: string) {
+    const idx = this.#idMap.get(id);
+    if (idx === undefined) return undefined;
+    return this.values[idx];
+  }
+  at(idx: number) {
+    return this.values.at(idx);
+  }
+  pickAt(idx: number) {
+    const value = this.values.at(idx);
+    if (value === undefined) throw new Error(`Value at ${idx} is undefined`);
+    return value;
+  }
+  pick(id: string) {
+    return this.values[this.indexOf(id)];
+  }
+  has(id: string) {
+    return this.#idMap.has(id);
+  }
+  find(fn: (value: Light, idx: number) => boolean) {
+    const val = this.values.find(fn);
+    return val;
+  }
+  findIndex(fn: (value: Light, idx: number) => boolean) {
+    const val = this.values.findIndex(fn);
+    return val;
+  }
+  some(fn: (value: Light, idx: number) => boolean) {
+    return this.values.some(fn);
+  }
+  every(fn: (value: Light, idx: number) => boolean) {
+    return this.values.every(fn);
+  }
+  forEach(fn: (value: Light, idx: number) => void) {
+    this.values.forEach(fn);
+  }
+  map<T>(fn: (value: Light, idx: number) => T) {
+    return this.values.map(fn);
+  }
+  flatMap<T>(fn: (value: Light, idx: number, array: Light[]) => T | readonly T[]) {
+    return this.values.flatMap(fn);
+  }
+  sort(fn: (a: Light, b: Light) => number) {
+    return new DataList(this.values.sort(fn));
+  }
+  filter(fn: (value: Light, idx: number) => boolean) {
+    return new DataList(this.values.filter(fn));
+  }
+  reduce<T>(fn: (acc: T, value: Light, idx: number) => T, initialValue: T) {
+    return this.values.reduce(fn, initialValue);
+  }
+  slice(start: number, end = this.length) {
+    return new DataList(this.values.slice(start, end));
+  }
+  save() {
+    return new DataList(this);
+  }
+  [Symbol.iterator]() {
+    return this.values[Symbol.iterator]();
+  }
+}
+
+export const version = "0.9.0";
+export const logo = `
+     _    _                  _     
+    / \\  | | ____ _ _ __    (_)___ 
+   / _ \\ | |/ / _' | '_ \\   | / __|
+  / ___ \\|   < (_| | | | |_ | \\__ \\
+ /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/
+                          |__/      ver ${version}
+? See more details on docs  https://www.akanjs.com/docs
+★ Star Akanjs on GitHub     https://github.com/aka-bassman/akanjs
+
+`;

package/src/baseEnv.ts

@@ -0,0 +1,110 @@
+export type Environment = "testing" | "debug" | "develop" | "main";
+export interface BaseEnv {
+  appName: string;
+  environment: Environment;
+  operationType: "server" | "client";
+  operationMode: "local" | "edge" | "cloud" | "module";
+  networkType: "mainnet" | "testnet" | "debugnet";
+}
+export type BackendEnv = BaseEnv & {
+  hostname: string | null;
+  appCode: number;
+  mongo: { password?: string };
+  port?: number;
+  mongoUri?: string;
+  redisUri?: string;
+  meiliUri?: string;
+  onCleanup?: () => Promise<void>;
+};
+
+//! Nextjs는 환경변수를 build time에 그냥 하드코딩으로 값을 넣어버림. operationMode같은것들 잘 동작안할 수 있음. 추후 수정 필요.
+// https://nextjs.org/docs/app/building-your-application/configuring/environment-variables#runtime-environment-variables
+const appName = process.env.NEXT_PUBLIC_APP_NAME ?? process.env.NX_TASK_TARGET_PROJECT ?? "unknown";
+if (appName === "unknown")
+  throw new Error("environment variable NEXT_PUBLIC_APP_NAME or NX_TASK_TARGET_PROJECT is required");
+const environment = (process.env.NEXT_PUBLIC_ENV ?? "debug") as BaseEnv["environment"];
+const operationType = typeof window !== "undefined" ? "client" : process.env.NEXT_RUNTIME ? "client" : "server";
+const operationMode = (process.env.NEXT_PUBLIC_OPERATION_MODE ?? "cloud") as BaseEnv["operationMode"];
+const networkType = (process.env.NEXT_PUBLIC_NETWORK_TYPE ??
+  (environment === "main" ? "mainnet" : environment === "develop" ? "testnet" : "debugnet")) as BaseEnv["networkType"];
+
+export const baseEnv: BaseEnv = {
+  appName,
+  environment,
+  operationType,
+  operationMode,
+  networkType,
+} as const;
+
+export type BaseClientEnv = BaseEnv & {
+  side: "server" | "client";
+  renderMode: "ssr" | "csr";
+  websocket: boolean;
+  clientHost: string;
+  clientPort: number;
+  clientHttpProtocol: "http:" | "https:";
+  clientHttpUri: string;
+  serverHost: string;
+  serverPort: number;
+  serverHttpProtocol: "http:" | "https:";
+  serverHttpUri: string;
+  serverGraphqlUri: string;
+  serverWsProtocol: "ws:" | "wss:";
+  serverWsUri: string;
+};
+
+const side = typeof window === "undefined" ? "server" : "client";
+const renderMode = (process.env.RENDER_ENV ?? "ssr") as BaseClientEnv["renderMode"];
+const clientHost =
+  process.env.NEXT_PUBLIC_CLIENT_HOST ??
+  (operationMode === "local" || side === "server" ? "localhost" : window.location.hostname);
+const clientPort = parseInt(
+  process.env.NEXT_PUBLIC_CLIENT_PORT ?? (operationMode === "local" ? (renderMode === "ssr" ? "4200" : "4201") : "443")
+);
+const clientHttpProtocol =
+  side === "client"
+    ? (window.location.protocol as "http:" | "https:")
+    : clientHost === "localhost"
+      ? "http:"
+      : "https:";
+const clientHttpUri = `${clientHttpProtocol}//${clientHost}${clientPort === 443 ? "" : `:${clientPort}`}`;
+const serverHost =
+  process.env.SERVER_HOST ??
+  (operationMode === "local"
+    ? typeof window === "undefined"
+      ? "localhost"
+      : window.location.host.split(":")[0]
+    : renderMode === "csr"
+      ? `${appName}-${environment}.akamir.com`
+      : side === "client"
+        ? window.location.host.split(":")[0]
+        : operationMode === "cloud"
+          ? `backend-svc.${appName}-${environment}.svc.cluster.local`
+          : "localhost");
+
+const serverPort = parseInt(
+  process.env.SERVER_PORT ?? (operationMode === "local" || side === "server" ? "8080" : "443")
+);
+const serverHttpProtocol = side === "client" ? (window.location.protocol as "http:" | "https:") : "http:";
+const serverHttpUri = `${serverHttpProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}/backend`;
+const serverGraphqlUri = `${serverHttpUri}/graphql`;
+const serverWsProtocol = serverHttpProtocol === "http:" ? "ws:" : "wss:";
+const serverWsUri = `${serverWsProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}`;
+
+export const baseClientEnv: BaseClientEnv = {
+  ...baseEnv,
+  side,
+  renderMode,
+  websocket: true,
+  clientHost,
+  clientPort,
+  clientHttpProtocol,
+  clientHttpUri,
+  serverHost,
+  serverPort,
+  serverHttpProtocol,
+  serverHttpUri,
+  serverGraphqlUri,
+  serverWsProtocol,
+  serverWsUri,
+} as const;

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./base";
+export * from "./baseEnv";
+export * from "./scalar";
+export * from "./types";

package/src/scalar.ts

@@ -0,0 +1,104 @@
+import dayjsLib, { Dayjs } from "dayjs";
+import type { ReadStream } from "fs";
+import type { Readable } from "stream";
+
+import type { GraphQLJSON, GraphQLUpload, Type } from "./types";
+
+export { Dayjs };
+
+export const dayjs = dayjsLib;
+export class BaseObject {
+  id: string;
+  createdAt: Dayjs;
+  updatedAt: Dayjs;
+  removedAt: Dayjs | null;
+}
+export class Int {
+  __Scalar__: "int";
+}
+export class Upload {
+  __Scalar__: "upload";
+  filename: string;
+  mimetype: string;
+  encoding: string;
+  createReadStream: () => ReadStream | Readable;
+}
+
+export class Float {
+  __Scalar__: "float";
+}
+export class ID {
+  __Scalar__: "id";
+}
+export class JSON {
+  __Scalar__: "json";
+}
+export type SingleFieldType =
+  | Int
+  | Float
+  | StringConstructor
+  | BooleanConstructor
+  | ID
+  | DateConstructor
+  | JSON
+  | Type
+  | GraphQLJSON
+  | GraphQLUpload;
+
+export const getNonArrayModel = <T = Type>(arraiedModel: T | T[]): [T, number] => {
+  let arrDepth = 0;
+  let target: T | T[] = arraiedModel;
+  while (Array.isArray(target)) {
+    target = target[0];
+    arrDepth++;
+  }
+  return [target, arrDepth];
+};
+export const arraiedModel = <T = any>(modelRef: T, arrDepth = 0) => {
+  let target: T | T[] | T[][] | T[][][] = modelRef;
+  for (let i = 0; i < arrDepth; i++) target = [target as T];
+  return target;
+};
+export const applyFnToArrayObjects = (arraiedData: any, fn: (arg: any) => any): any[] => {
+  if (Array.isArray(arraiedData)) return arraiedData.map((data) => applyFnToArrayObjects(data, fn) as unknown);
+  return fn(arraiedData) as unknown as any[];
+};
+
+export const gqlScalars = [String, Boolean, Date, ID, Int, Float, Upload, JSON, Map] as const;
+export type GqlScalar = (typeof gqlScalars)[number];
+export const gqlScalarNames = ["ID", "Int", "Float", "String", "Boolean", "Date", "Upload", "JSON", "Map"] as const;
+export type GqlScalarName = (typeof gqlScalarNames)[number];
+export const scalarSet = new Set<GqlScalar>([String, Boolean, Date, ID, Int, Float, Upload, JSON, Map]);
+export const scalarNameMap = new Map<GqlScalar, GqlScalarName>([
+  [ID, "ID"],
+  [Int, "Int"],
+  [Float, "Float"],
+  [String, "String"],
+  [Boolean, "Boolean"],
+  [Date, "Date"],
+  [Upload, "Upload"],
+  [JSON, "JSON"],
+  [Map, "Map"],
+]);
+export const scalarArgMap = new Map<GqlScalar, any>([
+  [ID, null],
+  [String, ""],
+  [Boolean, false],
+  [Date, dayjs(new Date(-1))],
+  [Int, 0],
+  [Float, 0],
+  [JSON, {}],
+  [Map, {}],
+]);
+export const scalarDefaultMap = new Map<GqlScalar, any>([
+  [ID, null],
+  [String, ""],
+  [Boolean, false],
+  [Date, dayjs(new Date(-1))],
+  [Int, 0],
+  [Float, 0],
+  [JSON, {}],
+]);
+export const isGqlClass = (modelRef: Type) => !scalarSet.has(modelRef);
+export const isGqlScalar = (modelRef: Type) => scalarSet.has(modelRef);
+export const isGqlMap = (modelRef: any) => modelRef === Map;

package/src/types.ts

@@ -0,0 +1,50 @@
+export type Type<T = any> = new (...args: any[]) => T;
+
+export type BufferLike =
+  | string
+  | Buffer
+  | DataView
+  | number
+  | ArrayBufferView
+  | Uint8Array
+  | ArrayBuffer
+  | SharedArrayBuffer
+  | readonly any[]
+  | readonly number[];
+
+export type GetObject<T> = Omit<{ [K in keyof T]: T[K] }, "prototype">;
+export type OptionOf<Obj> = {
+  [K in keyof Obj]?: Obj[K] | null;
+};
+export type UnType<T> = T extends new (...args: any) => infer U ? U : never;
+
+export interface GraphQLUpload {
+  name: string;
+  description: string;
+  specifiedByUrl: string;
+  serialize: any;
+  parseValue: any;
+  parseLiteral: any;
+  extensions: any;
+  astNode: any;
+  extensionASTNodes: any;
+  toConfig(): any;
+  toString(): string;
+  toJSON(): string;
+  inspect(): string;
+}
+export interface GraphQLJSON<TInternal = unknown, TExternal = TInternal> {
+  name: string;
+  description: string;
+  specifiedByURL: string;
+  serialize: any;
+  parseValue: any;
+  parseLiteral: any;
+  extensions: any;
+  astNode: any;
+  extensionASTNodes: any;
+  get [Symbol.toStringTag](): string;
+  toConfig(): any;
+  toString(): string;
+  toJSON(): string;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "jsx": "preserve"
+  },
+  "files": [],
+  "include": ["**/*.ts"],
+  "references": [
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["jest", "node"]
+  },
+  "include": ["jest.config.ts", "**/*.test.ts"]
+}