akanjs 0.0.1 → 2.0.0-beta.1

package/service/predefinedAdaptor/cache.adaptor.ts

@@ -0,0 +1,105 @@
+import type { BaseEnv, Dayjs, SshOptions } from "akanjs/base";
+import type { Redis } from "ioredis";
+import { adapt } from "../adapt";
+
+export interface CacheAdaptor {
+  set(topic: string, key: string, value: string | number | Buffer, option?: { expireAt?: Dayjs }): Promise<void>;
+  get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined>;
+  delete(topic: string, key: string): Promise<void>;
+  getClient?(): Redis;
+  hset(
+    topic: string,
+    key: string,
+    subKey: string,
+    value: string | number | Buffer,
+    option?: { expireAt?: Dayjs },
+  ): Promise<void>;
+  hget<T extends string | number | Buffer>(topic: string, key: string, subKey: string): Promise<T | undefined>;
+  hdelete(topic: string, key: string, subKey: string): Promise<void>;
+}
+
+interface RedisEnv extends BaseEnv {
+  redis?: { username?: string; password?: string; sshOptions?: SshOptions };
+}
+
+export class RedisCache
+  extends adapt("redisCache", ({ env }) => ({
+    redis: env(
+      async ({
+        appName,
+        environment,
+        serveDomain,
+        operationMode,
+        repoName,
+        redis = {
+
+          sshOptions: {
+            host: `${appName}-${environment}.${serveDomain}`,
+            port: 32767,
+            username: process.env.TUNNEL_USERNAME ?? "root",
+            password: process.env.TUNNEL_PASSWORD ?? repoName,
+            dstPort: 6379,
+          },
+        },
+      }: RedisEnv) => {
+        const createRedis = async (url: string) => {
+          const { Redis } = await import("ioredis");
+          const redis = new Redis(url, { lazyConnect: true });
+          await redis.connect();
+          return redis;
+        };
+        if (process.env.REDIS_URI) return await createRedis(process.env.REDIS_URI);
+        else if (environment === "local") return await createRedis("redis://localhost:6379");
+        if (operationMode === "cloud")
+          return await createRedis(`redis://redis-svc.${appName}-${environment}.svc.cluster.local`);
+        else if (operationMode === "local")
+          return await createRedis(`redis://${process.env.REDIS_HOST ?? "localhost"}`);
+        else return await createRedis(`redis://localhost:6379`);
+      },
+    ),
+  }))
+  implements CacheAdaptor
+{
+  async set(
+    topic: string,
+    key: string,
+    value: string | number | Buffer,
+    option: { expireAt?: Dayjs } = {},
+  ): Promise<void> {
+    const expireTime = option.expireAt?.toDate().getTime();
+    if (expireTime) await this.redis.set(`${topic}:${key}`, value, "PXAT", expireTime);
+    else await this.redis.set(`${topic}:${key}`, value);
+  }
+  async get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined> {
+    const value = await this.redis.get(`${topic}:${key}`);
+    return value as T | undefined;
+  }
+  async delete(topic: string, key: string) {
+    await this.redis.del(`${topic}:${key}`);
+  }
+  async hset(
+    topic: string,
+    key: string,
+    subKey: string,
+    value: string | number | Buffer,
+    option?: { expireAt?: Dayjs },
+  ): Promise<void> {
+    const expireTime = option?.expireAt?.toDate().getTime();
+    const redisKey = `${topic}:${key}`;
+    await this.redis.hset(redisKey, subKey, value);
+    if (expireTime) await this.redis.pexpireat(redisKey, expireTime);
+  }
+  async hget<T extends string | number | Buffer>(topic: string, key: string, subKey: string): Promise<T | undefined> {
+    const value = await this.redis.hget(`${topic}:${key}`, subKey);
+    return value as T | undefined;
+  }
+  async hdelete(topic: string, key: string, subKey: string): Promise<void> {
+    await this.redis.hdel(`${topic}:${key}`, subKey);
+  }
+  getClient(): Redis {
+    return this.redis;
+  }
+  override async onDestroy() {
+    this.redis.disconnect();
+  }
+}

package/service/predefinedAdaptor/compress.adaptor.ts

@@ -0,0 +1,357 @@
+import {
+  Any,
+  applyFnToArrayObjects,
+  type Cls,
+  type Dayjs,
+  dayjs,
+  FIELD_META,
+  Float,
+  getNonArrayModel,
+  ID,
+  Int,
+  PrimitiveRegistry,
+  type PrimitiveScalar,
+} from "akanjs/base";
+import { Logger } from "akanjs/common";
+import { type ConstantCls, type ConstantField, ConstantRegistry } from "akanjs/constant";
+import * as proto from "protobufjs";
+import { adapt } from "../adapt";
+
+export interface CompressAdaptor {
+  encode(ref: Cls, arrDepth: number, value: unknown): Buffer | null;
+  decode<T = unknown>(ref: Cls, arrDepth: number, buffer: Buffer): T;
+}
+
+export class ProtobufCompressor extends adapt("protobufCompressor", () => ({})) implements CompressAdaptor {
+  #protobufTypeMap = new Map<unknown, string>([
+    [String, "string"],
+    [Int, "int32"],
+    [Float, "float"],
+    [Boolean, "bool"],
+    [Date, "double"],
+  ]);
+  #primitiveProtoEncodeMap = new Map<PrimitiveScalar, (value: never) => unknown>([
+    [Date, (value: Date | Dayjs) => dayjs(value).toDate().getTime()],
+    [String, (value: string) => value],
+    [ID, (value: string) => value],
+    [Boolean, (value: boolean) => value],
+    [Int, (value: number) => value],
+    [Float, (value: number) => value],
+    [Any, (value: object) => JSON.stringify(value)],
+  ]);
+  #primitiveProtoDecodeMap = new Map<PrimitiveScalar, (value: never) => unknown>([
+    [Date, (value: Date | Dayjs) => dayjs(value).toDate()],
+    [String, (value: string) => value],
+    [ID, (value: string) => value],
+    [Boolean, (value: boolean) => value],
+    [Int, (value: number) => value],
+    [Float, (value: number) => value],
+    [Any, (value: string) => JSON.parse(value) as object],
+  ]);
+  #protoModelMap = new Map<Cls, proto.Type>();
+  #protoEncodeMap = new Map<Cls, (value: never) => object>();
+  #protoDecodeMap = new Map<Cls, (value: never) => object>();
+  #protoWrapperMap = new Map<string, proto.Type>();
+
+  #getProtoModel(modelRef: ConstantCls<unknown>) {
+    const refName = ConstantRegistry.getRefName(modelRef);
+    const predefinedProtoModel = this.#protoModelMap.get(modelRef);
+    if (predefinedProtoModel) return predefinedProtoModel;
+    const namespace = refName.toLowerCase();
+    const allModelRefs = this.#getRelatedProtoModelRefs(modelRef, [...modelRef.children, ...modelRef.relations]);
+
+    const modelDatas = allModelRefs.map((modelRef) => {
+      const refName = ConstantRegistry.getRefName(modelRef);
+      return [
+        refName,
+        {
+          fields: Object.fromEntries(
+            Object.entries(modelRef[FIELD_META]).map(([key, field], id) => {
+              const rule = field.isArray ? "repeated" : field.nullable ? "optional" : "required";
+              const type = this.#getProtoFieldType(field);
+              if (field.isMap) return [key, { keyType: "string", type, id }] as [string, proto.IMapField];
+              return [key, { type, id, rule }] as [string, proto.IField];
+            }),
+          ),
+        },
+      ] as [string, proto.IType];
+    });
+    const modelJson = Object.fromEntries(modelDatas);
+
+    const enumDatas = allModelRefs.flatMap((modelRef) => {
+      const enumJsons = [...modelRef.enums].map((enumCls) => {
+        const enumData: proto.IEnum = {
+          values: Object.fromEntries(enumCls.values.map((value, idx) => [value, idx])),
+        };
+        return [enumCls.refName, enumData] as [string, proto.IEnum];
+      });
+      return enumJsons;
+    });
+    const enumJson = Object.fromEntries(enumDatas);
+    const protoJson: proto.INamespace = { nested: { [namespace]: { nested: { ...modelJson, ...enumJson } } } };
+    const root = proto.Root.fromJSON(protoJson);
+    const protoModel = root.lookupType(`${namespace}.${refName}`);
+    this.#protoModelMap.set(modelRef, protoModel);
+    return protoModel;
+  }
+
+  #getProtoEncodeFn(modelRef: Cls) {
+    const [valueRef] = getNonArrayModel(modelRef);
+    return this.#primitiveProtoEncodeMap.get(valueRef) ?? ((value) => value as object);
+  }
+  #getRelatedProtoModelRefs(modelRef: ConstantCls, baseModelRefs: ConstantCls[] = []) {
+    const allModelRefs = [modelRef, ...baseModelRefs];
+    allModelRefs.forEach((mRef) => {
+      Object.values(mRef[FIELD_META]).forEach((field) => {
+        const relatedRef = field.isMap && field.of ? (field.of as Cls) : field.modelRef;
+        if (!PrimitiveRegistry.has(relatedRef) && !allModelRefs.includes(relatedRef as ConstantCls)) {
+          allModelRefs.push(relatedRef as ConstantCls);
+        }
+      });
+    });
+    return allModelRefs;
+  }
+  #getProtoFieldType(field: ConstantField) {
+    const modelRef = field.isMap && field.of ? (field.of as Cls) : field.modelRef;
+    return field.isClass || (field.isMap && field.of && !PrimitiveRegistry.has(field.of as Cls))
+      ? ConstantRegistry.getRefName(modelRef)
+      : field.enum
+        ? field.enum.refName
+        : (this.#protobufTypeMap.get(modelRef) ?? "string");
+  }
+  #protoEncode(
+    field: ConstantField,
+    value: unknown,
+  ): object | object[] | Map<string, unknown> | number | string | boolean | null {
+    if (field.nullable && (value === null || value === undefined)) return null;
+    if (field.isArray && Array.isArray(value)) {
+      return (value as object[]).map((v: object) => this.#protoEncode(field, v) as object) as object[];
+    }
+    if (field.isMap && field.of) {
+      const protoEncodeFn = this.#getProtoEncodeFn(field.of as Cls);
+      return Object.fromEntries(
+        [...(value as Map<string, unknown>).entries()].map(([key, val]) => [
+          key,
+          applyFnToArrayObjects(val, protoEncodeFn),
+        ]),
+      );
+    }
+    if (field.isClass) return this.#makeProtoEncode(field.modelRef)(value as never);
+    if (field.enum) return field.enum.indexOf(value as string);
+    return this.#getProtoEncodeFn(field.modelRef)(value as never) as
+      | object
+      | object[]
+      | Map<string, unknown>
+      | number
+      | string
+      | boolean
+      | null;
+  }
+  #makeProtoEncode = <T>(modelRef: ConstantCls<T>): ((value: never) => object) => {
+    const predefinedProtoEncode = this.#protoEncodeMap.get(modelRef);
+    if (predefinedProtoEncode) return predefinedProtoEncode;
+    const protoEncodeFn = (value: T) => {
+      const result: Record<string, unknown> = {};
+      Object.entries(modelRef[FIELD_META]).forEach(([key, field], id) => {
+        result[key] = this.#protoEncode(field, value[key as keyof T]) as object;
+      });
+      return result;
+    };
+    this.#protoEncodeMap.set(modelRef, protoEncodeFn as (value: never) => object);
+    return protoEncodeFn as (value: never) => object;
+  };
+  #encode = (modelRef: ConstantCls, value: object) => {
+    try {
+      const protoModel = this.#getProtoModel(modelRef);
+      const protoEncode = this.#makeProtoEncode(modelRef);
+      const data = protoEncode(value as never);
+      const errMsg = protoModel.verify(data);
+      if (errMsg) throw new Error(errMsg);
+      const message = protoModel.create(data);
+      const buffer = protoModel.encode(message).finish();
+      return buffer as unknown as Buffer;
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      Logger.error(`Failed to encode ${modelRef.name}: ${errMsg}`);
+      return null;
+    }
+  };
+  encode(ref: Cls, arrDepth: number, value: unknown): Buffer | null {
+    if (arrDepth === 0 && !PrimitiveRegistry.has(ref)) return this.#encode(ref as ConstantCls, value as object);
+    try {
+      const isPrimitive = PrimitiveRegistry.has(ref);
+      const wrapperType = this.#getWrapperProtoModel(ref, arrDepth);
+      const isArray = arrDepth > 0;
+      const fieldName = isArray ? "values" : "value";
+
+      let encoded: unknown;
+      if (isPrimitive) {
+        const encodeFn = (this.#primitiveProtoEncodeMap.get(ref) ?? ((v: never) => v)) as (value: unknown) => unknown;
+        encoded = isArray ? (value as unknown[]).map((v) => encodeFn(v)) : encodeFn(value);
+      } else {
+        const modelRef = ref as ConstantCls;
+        const protoEncode = this.#makeProtoEncode(modelRef);
+        encoded = isArray
+          ? (value as object[]).map((v: object) => protoEncode(v as never))
+          : protoEncode(value as never);
+      }
+
+      const data = { [fieldName]: encoded };
+      const errMsg = wrapperType.verify(data);
+      if (errMsg) throw new Error(errMsg);
+      const message = wrapperType.create(data);
+      const buffer = wrapperType.encode(message).finish();
+      return buffer as unknown as Buffer;
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      Logger.error(`Failed to encodeValue: ${errMsg}`);
+      return null;
+    }
+  }
+
+  #getProtoDecodeFn(modelRef: Cls) {
+    const [valueRef] = getNonArrayModel(modelRef);
+    return this.#primitiveProtoDecodeMap.get(valueRef) ?? ((value) => value as object);
+  }
+  #protoDecode(
+    field: ConstantField,
+    value: unknown,
+  ): object | object[] | Map<string, unknown> | number | string | boolean | null | undefined {
+    if (field.nullable && (value === null || value === undefined)) return null;
+    if (field.isArray) {
+      if (value === undefined) return [];
+      if (Array.isArray(value))
+        return (value as object[]).map((v: object) => this.#protoDecode(field, v) as object) as object[];
+    }
+    if (field.isMap && field.of) {
+      const protoDecodeFn = this.#getProtoDecodeFn(field.of as Cls);
+      if (value === null || value === undefined) return new Map();
+      return new Map(
+        Object.entries(value as { [key: string]: string | number }).map(([key, val]) => [
+          key,
+          applyFnToArrayObjects(val, protoDecodeFn),
+        ]),
+      );
+    }
+    if (field.isClass) return this.#makeProtoDecode(field.modelRef)(value as never);
+    if (field.enum) return field.enum.values.at(value as number);
+    return this.#getProtoDecodeFn(field.modelRef)(value as never) as
+      | object
+      | object[]
+      | Map<string, unknown>
+      | number
+      | string
+      | boolean
+      | null
+      | undefined;
+  }
+  #makeProtoDecode<T>(modelRef: ConstantCls<T>): (value: never) => object {
+    const predefinedProtoDecode = this.#protoDecodeMap.get(modelRef);
+    if (predefinedProtoDecode) return predefinedProtoDecode;
+    const protoDecodeFn = (value: T) => {
+      const result: Record<string, unknown> = {};
+      Object.entries(modelRef[FIELD_META]).forEach(([key, field], id) => {
+        result[key] = this.#protoDecode(field, value[key as keyof T]) as object;
+      });
+      return result;
+    };
+    this.#protoDecodeMap.set(modelRef, protoDecodeFn as (value: never) => object);
+    return protoDecodeFn as (value: never) => object;
+  }
+  #decode<T>(modelRef: ConstantCls<T>, buffer: Buffer, { raw = false }: { raw?: boolean } = {}): T {
+    const protoModel = this.#getProtoModel(modelRef as unknown as ConstantCls<unknown>);
+    const message = protoModel.decode(Buffer.from(buffer));
+    const data = protoModel.toObject(message);
+    const protoDecode = this.#makeProtoDecode(modelRef);
+    const decoded = protoDecode(data as never) as T;
+    if (raw) return decoded;
+    return new modelRef().set(decoded);
+  }
+
+  #getWrapperProtoModel(ref: Cls, arrDepth: number): proto.Type {
+    const isPrimitive = PrimitiveRegistry.has(ref);
+    const refName = isPrimitive
+      ? PrimitiveRegistry.getName(ref as typeof PrimitiveScalar)
+      : ConstantRegistry.getRefName(ref as ConstantCls);
+    const cacheKey = `${refName}:${arrDepth}`;
+    const cachedProtoWrapper = this.#protoWrapperMap.get(cacheKey);
+    if (cachedProtoWrapper) return cachedProtoWrapper;
+
+    const isArray = arrDepth > 0;
+    const rule = isArray ? "repeated" : "required";
+    const fieldName = isArray ? "values" : "value";
+
+    const nested: { [key: string]: proto.IType | proto.IEnum } = {};
+    const fieldType = isPrimitive ? (this.#protobufTypeMap.get(ref) ?? "string") : refName;
+
+    if (!isPrimitive) {
+      const modelRef = ref as ConstantCls;
+      const allModelRefs = this.#getRelatedProtoModelRefs(modelRef, [...modelRef.children]);
+
+      for (const mRef of allModelRefs) {
+        const mRefName = ConstantRegistry.getRefName(mRef);
+        nested[mRefName] = {
+          fields: Object.fromEntries(
+            Object.entries(mRef[FIELD_META]).map(([key, field], id) => {
+              const fRule = field.isArray ? "repeated" : field.nullable ? "optional" : "required";
+              const fType = this.#getProtoFieldType(field);
+              if (field.isMap) return [key, { keyType: "string", type: fType, id }] as [string, proto.IMapField];
+              return [key, { type: fType, id, rule: fRule }] as [string, proto.IField];
+            }),
+          ),
+        };
+      }
+      for (const mRef of allModelRefs)
+        for (const enumCls of mRef.enums)
+          nested[enumCls.refName] = {
+            values: Object.fromEntries(enumCls.values.map((value, idx) => [value, idx])),
+          } as proto.IEnum;
+    }
+
+    const wrapperTypeName = `Wrapper_${refName}_${arrDepth}`;
+    nested[wrapperTypeName] = {
+      fields: { [fieldName]: { type: fieldType, id: 1, rule } },
+    };
+
+    const namespace = `wrapper_${refName.toLowerCase()}_${arrDepth}`;
+    const protoJson: proto.INamespace = {
+      nested: { [namespace]: { nested } },
+    };
+    const root = proto.Root.fromJSON(protoJson);
+    const wrapperType = root.lookupType(`${namespace}.${wrapperTypeName}`);
+    this.#protoWrapperMap.set(cacheKey, wrapperType);
+    return wrapperType;
+  }
+
+  decode<T = unknown>(ref: Cls, arrDepth: number, buffer: Buffer, { raw = false }: { raw?: boolean } = {}): T {
+    if (arrDepth === 0 && !PrimitiveRegistry.has(ref)) return this.#decode(ref as ConstantCls<T>, buffer, { raw });
+
+    const isPrimitive = PrimitiveRegistry.has(ref);
+    const wrapperType = this.#getWrapperProtoModel(ref, arrDepth);
+    const isArray = arrDepth > 0;
+    const fieldName = isArray ? "values" : "value";
+
+    const message = wrapperType.decode(Buffer.from(buffer));
+    const data = wrapperType.toObject(message);
+    const rawObj = data[fieldName];
+
+    if (isPrimitive) {
+      const decodeFn = (this.#primitiveProtoDecodeMap.get(ref) ?? ((v: never) => v)) as (value: unknown) => unknown;
+      if (isArray) return ((rawObj as unknown[]) ?? []).map((v) => decodeFn(v)) as T;
+      return decodeFn(rawObj) as T;
+    }
+    const modelRef = ref as ConstantCls;
+    const protoDecode = this.#makeProtoDecode(modelRef);
+    if (isArray)
+      return ((rawObj as object[]) ?? []).map((v: object) => {
+        const decoded = protoDecode(v as never);
+        if (raw) return decoded;
+        return new modelRef().set(decoded);
+      }) as T;
+    else {
+      const decoded = protoDecode(rawObj as never);
+      if (raw) return decoded as T;
+      return new modelRef().set(decoded);
+    }
+  }
+}