akanjs 0.0.1 → 2.0.0-beta.1

package/base/symbols.ts

@@ -0,0 +1,11 @@
+export const FIELD_META = Symbol.for("akanjs.field");
+export const SLICE_META = Symbol.for("akanjs.slice");
+export const FILTER_META = Symbol.for("akanjs.filter");
+export const LOADER_META = Symbol.for("akanjs.loader");
+export const INJECT_META = Symbol.for("akanjs.inject");
+export const ENDPOINT_META = Symbol.for("akanjs.endpoint");
+export const INTERNAL_META = Symbol.for("akanjs.internal");
+export const STATE_META = Symbol.for("akanjs.state");
+export const STATE_INIT_META = Symbol.for("akanjs.state.init");
+export const STATE_DERIVED_META = Symbol.for("akanjs.state.derived");
+export const ACTION_META = Symbol.for("akanjs.action");

package/base/types.ts

@@ -0,0 +1,137 @@
+import type { Dayjs } from "dayjs";
+
+export type SshOptions = { host: string; port: number; username: string; password: string; dstPort?: number };
+
+export type Cls<T = unknown, Statics = unknown> = (new (...args: never[]) => T) & Statics;
+
+export type BufferLike =
+  | string
+  | Buffer
+  | DataView
+  | number
+  | ArrayBufferView
+  | Uint8Array
+  | ArrayBuffer
+  | SharedArrayBuffer
+  | readonly unknown[]
+  | readonly number[];
+
+export type GetObject<T> = {
+  [K in keyof T as K extends "prototype" ? never : K]: T[K];
+};
+export type OptionOf<Obj> = Partial<{
+  [K in keyof Obj]: Obj[K] | null;
+}>;
+export type UnCls<T> = T extends new (...args: infer _Args) => infer U ? U : never;
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type GetStateObject<T> = {
+  [K in keyof T as T[K] extends (...args: never[]) => unknown ? never : K extends "prototype" ? never : K]: T[K];
+};
+export type GetActionObject<T> = {
+  [K in keyof T as T[K] extends (...args: never[]) => unknown ? (K extends "prototype" ? never : K) : never]: T[K];
+};
+
+export type PromiseOrObject<T> = T | Promise<T>;
+type MergeObjectValues<T> = T extends Record<string, infer V> ? (V extends object ? V : never) : never;
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type MergedValues<T> = UnionToIntersection<MergeObjectValues<T>>;
+export type Assign<A, B> = Omit<A, keyof B> & B;
+
+export type ObjectAssign<Objects extends object[], Acc = unknown> = Objects extends [
+  infer First extends object,
+  ...infer Rest extends object[],
+]
+  ? ObjectAssign<Rest, Assign<Acc, First>>
+  : Acc;
+
+export type MergeAll<T extends object[], Acc = unknown> = T extends [
+  infer First extends object,
+  ...infer Rest extends object[],
+]
+  ? MergeAll<Rest, Acc & First>
+  : Acc;
+
+export type MergeAllActionTypes<T extends Cls[], OmitKey extends string = never, Acc = unknown> = T extends [
+  infer First extends Cls,
+  ...infer Rest extends Cls[],
+]
+  ? Rest extends []
+    ? Acc & Omit<GetActionObject<UnCls<First>>, OmitKey>
+    : MergeAllActionTypes<Rest, OmitKey, Acc & Omit<UnCls<First>, OmitKey>>
+  : Acc;
+
+export type MergeAllTypes<T extends Cls[], OmitKey extends string = never, Acc = unknown> = T extends [
+  infer First extends Cls,
+  ...infer Rest extends Cls[],
+]
+  ? MergeAllTypes<Rest, OmitKey, Acc & Omit<UnCls<First>, OmitKey>>
+  : Acc;
+
+export type MergeAllKeyOfTypes<T extends Cls<object>[], Key extends PropertyKey, Acc = unknown> = T extends [
+  infer First extends Cls<object>,
+  ...infer Rest extends Cls<object>[],
+]
+  ? Key extends keyof UnCls<First>
+    ? MergeAllKeyOfTypes<Rest, Key, Acc & UnCls<First>[Key]>
+    : MergeAllKeyOfTypes<Rest, Key, Acc>
+  : Acc;
+
+export type MergeAllKeyOfObjects<T extends object[], Key extends PropertyKey, Acc = unknown> = T extends [
+  infer First extends object,
+  ...infer Rest extends object[],
+]
+  ? Key extends keyof First
+    ? MergeAllKeyOfObjects<Rest, Key, Acc & First[Key]>
+    : MergeAllKeyOfObjects<Rest, Key, Acc>
+  : Acc;
+
+export type MergeAllDoubleKeyOfObjects<
+  T extends object[],
+  Key extends PropertyKey,
+  SubKey extends PropertyKey,
+  Acc = unknown,
+> = T extends [infer First extends object, ...infer Rest extends object[]]
+  ? Key extends keyof First
+    ? First[Key] extends object
+      ? SubKey extends keyof First[Key]
+        ? MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc & First[Key][SubKey]>
+        : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc>
+      : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc>
+    : MergeAllDoubleKeyOfObjects<Rest, Key, SubKey, Acc>
+  : Acc;
+
+export type Primitive = string | number | boolean | null | undefined; 
+
+export type NestedKeysWithAllowed<T, Allowed = Primitive> = T extends Primitive
+  ? never
+  : T extends unknown[]
+    ? never
+    : T extends (...args: never[]) => unknown
+      ? never
+      : {
+          [K in keyof T & string]: T[K] extends Allowed
+            ? K
+            : T[K] extends Dayjs
+              ? never
+              : T[K] extends readonly unknown[]
+                ? never
+                : T[K] extends (...args: never[]) => unknown
+                  ? never
+                  : T[K] extends object
+                    ? K | `${K}.${NestedKeysWithAllowed<T[K], Allowed>}`
+                    : never;
+        }[keyof T & string];
+
+export type SingleValue<Value> = Value extends (infer V)[] ? SingleValue<V> : Value;
+
+export type StrArrToObject<Arr, Value> = Arr extends [infer First, ...infer Rest]
+  ? { [K in First & string]: Value } & StrArrToObject<Rest, Value>
+  : unknown;
+
+export type GetValueOfKey<Model, Key extends string, Fallback = never> = Model extends { [key in Key]: unknown }
+  ? Model[Key]
+  : Fallback;

package/base/utils.ts

@@ -0,0 +1,30 @@
+export const getNonArrayModel = <T>(arraiedModel: T | T[]): [T, number] => {
+  let arrDepth = 0;
+  let target: T | T[] = arraiedModel;
+  while (Array.isArray(target)) {
+    target = target[0] as T;
+    arrDepth++;
+  }
+  return [target, arrDepth];
+};
+export const arraiedModel = <T = unknown>(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 type ApplyFnToArrayObjectsResult<Input, Output> = Input extends readonly (infer Item)[]
+  ? ApplyFnToArrayObjectsResult<Item, Output>[]
+  : Output;
+
+export const applyFnToArrayObjects = <Input, Fn extends (arg: never) => unknown>(
+  arraiedData: Input,
+  fn: Fn,
+): ApplyFnToArrayObjectsResult<Input, ReturnType<Fn>> => {
+  if (Array.isArray(arraiedData))
+    return arraiedData.map((data) => applyFnToArrayObjects(data, fn)) as ApplyFnToArrayObjectsResult<
+      Input,
+      ReturnType<Fn>
+    >;
+  return fn(arraiedData as never) as ApplyFnToArrayObjectsResult<Input, ReturnType<Fn>>;
+};

package/cli/application/application.command.ts

@@ -0,0 +1,213 @@
+import { select } from "@inquirer/prompts";
+import { App, command, Exec, Sys, Workspace } from "akanjs/devkit";
+
+import { ApplicationScript } from "./application.script";
+
+const asMobileEnv = (env: string) => env as "local" | "debug" | "develop" | "main";
+
+export class ApplicationCommand extends command("application", [ApplicationScript], ({ public: target }) => ({
+  createApplication: target({ desc: "Create a new application in the workspace" })
+    .arg("appName", String, { desc: "name of application" })
+    .option("start", Boolean, { desc: "start application", default: false })
+    .with(Workspace)
+    .exec(async function (appName, start, workspace) {
+      await this.applicationScript.createApplication(appName.toLowerCase().replace(/ /g, "-"), workspace, { start });
+    }),
+  removeApplication: target({ desc: "Remove an application from the workspace" })
+    .with(App)
+    .exec(async function (app) {
+      await this.applicationScript.removeApplication(app);
+    }),
+  sync: target({ desc: "Sync dependencies and configuration for an app or library" })
+    .with(Sys)
+    .exec(async function (sys) {
+      await this.applicationScript.sync(sys);
+    }),
+  script: target({ desc: "Run a custom script in the application" })
+    .with(App)
+    .arg("filename", String, { desc: "name of script", nullable: true })
+    .exec(async function (app, filename) {
+      await this.applicationScript.script(app, filename);
+    }),
+  build: target({ short: true, desc: "Build the application for production (frontend + backend)" })
+    .with(App)
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("fast", Boolean, { desc: "fast build", default: false })
+    .option("quiet", Boolean, { desc: "hide build progress output", default: false })
+    .exec(async function (app, write, fast, quiet) {
+      await this.applicationScript.build(app, { write, fast, quiet });
+    }),
+  typecheck: target({ short: true, desc: "Typecheck the application" })
+    .with(App)
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("clean", Boolean, { desc: "clear typecheck cache before running", default: false })
+    .option("incremental", Boolean, { desc: "reuse TypeScript incremental cache", default: true })
+    .exec(async function (app, write, clean, incremental) {
+      await this.applicationScript.typecheck(app, { write, clean, incremental });
+    }),
+  test: target({ desc: "Prepare and test an app, library, or package" })
+    .with(Exec)
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .exec(async function (exec, write) {
+      await this.applicationScript.test(exec, { write });
+    }),
+  buildIos: target({ short: true, desc: "Build iOS app with Capacitor" })
+    .with(App)
+    .option("target", String, { desc: "mobile target name or all" })
+    .option("env", String, {
+      enum: ["local", "debug", "develop", "main"],
+      desc: "backend environment",
+      default: "debug",
+    })
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false })
+    .exec(async function (app, target, env, write, regenerate) {
+      await this.applicationScript.buildIos(app, { target, env: asMobileEnv(env), write, regenerate });
+    }),
+  buildAndroid: target({ short: true, desc: "Build Android app with Capacitor" })
+    .with(App)
+    .option("target", String, { desc: "mobile target name or all" })
+    .option("env", String, {
+      enum: ["local", "debug", "develop", "main"],
+      desc: "backend environment",
+      default: "debug",
+    })
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false })
+    .exec(async function (app, target, env, write, regenerate) {
+      await this.applicationScript.buildAndroid(app, { target, env: asMobileEnv(env), write, regenerate });
+    }),
+  start: target({ short: true, desc: "Start development server (frontend SSR + backend)" })
+    .with(App)
+    .option("open", Boolean, { desc: "open web browser?", default: false })
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .exec(async function (app, open, write) {
+      await this.applicationScript.start(app, { open, write });
+    }),
+  startIos: target({ short: true, desc: "Start iOS app in simulator or device" })
+    .with(App)
+    .option("target", String, { desc: "mobile target name or all" })
+    .option("env", String, {
+      enum: ["local", "debug", "develop", "main"],
+      desc: "backend environment",
+      default: "local",
+    })
+    .option("open", Boolean, { desc: "open ios simulator", default: false })
+    .option("release", Boolean, { desc: "release mode", default: false })
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false })
+    .exec(async function (app, target, env, open, release, write, regenerate) {
+      await this.applicationScript.startIos(app, {
+        target,
+        env: asMobileEnv(env),
+        open,
+        operation: release ? "release" : "local",
+        write,
+        regenerate,
+      });
+    }),
+  startAndroid: target({ short: true, desc: "Start Android app in emulator or device" })
+    .with(App)
+    .option("target", String, { desc: "mobile target name or all" })
+    .option("env", String, {
+      enum: ["local", "debug", "develop", "main"],
+      desc: "backend environment",
+      default: "local",
+    })
+    .option("release", Boolean, { desc: "release mode", default: false })
+    .option("open", Boolean, { desc: "open android simulator", default: false })
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false })
+    .exec(async function (app, target, env, release, open, write, regenerate) {
+      await this.applicationScript.startAndroid(app, {
+        target,
+        env: asMobileEnv(env),
+        open,
+        operation: release ? "release" : "local",
+        write,
+        regenerate,
+      });
+    }),
+  releaseIos: target({ desc: "Build and package iOS app for release (App Store)" })
+    .with(App)
+    .option("target", String, { desc: "mobile target name or all" })
+    .option("env", String, {
+      enum: ["debug", "develop", "main", "local"],
+      desc: "backend environment",
+      default: "main",
+    })
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false })
+    .option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false })
+    .exec(async function (app, target, env, write, regenerate, allowLocalRelease) {
+      await this.applicationScript.releaseIos(app, {
+        target,
+        env: asMobileEnv(env),
+        write,
+        regenerate,
+        allowLocalRelease,
+      });
+    }),
+  releaseAndroid: target({ desc: "Build and package Android app for release (Play Store)" })
+    .with(App)
+    .option("assembleType", String, { enum: ["apk", "aab"], default: "apk" })
+    .option("target", String, { desc: "mobile target name or all" })
+    .option("env", String, {
+      enum: ["debug", "develop", "main", "local"],
+      desc: "backend environment",
+      default: "main",
+    })
+    .option("write", Boolean, { desc: "write code generation", default: true })
+    .option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false })
+    .option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false })
+    .exec(async function (app, assembleType, target, env, write, regenerate, allowLocalRelease) {
+      await this.applicationScript.releaseAndroid(app, assembleType as "apk" | "aab", {
+        target,
+        env: asMobileEnv(env),
+        write,
+        regenerate,
+        allowLocalRelease,
+      });
+    }),
+  releaseSource: target({ desc: "Release app source code with OTA update support" })
+    .with(App)
+    .option("rebuild", Boolean, { desc: "rebuild", default: false })
+    .option("buildNum", Number, { desc: "build number", default: 0 })
+    .option("environment", String, { desc: "environment", default: "debug" })
+    .option("local", Boolean, { desc: "local", default: true })
+    .exec(async function (app, rebuild, buildNum, environment, local) {
+      await this.applicationScript.releaseSource(app, { rebuild, buildNum, environment, local });
+    }),
+  codepush: target({ desc: "Deploy over-the-air (OTA) update for mobile app" })
+    .with(App)
+    .exec(async function (app) {
+      const os: "ios" | "android" = await select({
+        message: "Select os",
+        choices: [
+          { value: "ios", name: "ios", description: "ios" },
+          { value: "android", name: "android", description: "android" },
+        ],
+      });
+      await this.applicationScript.codepush(app, os);
+    }),
+  dbup: target({ desc: "Start local database services for a database mode" })
+    .with(Workspace)
+    .option("mode", String, {
+      desc: "database mode",
+      default: "multiple",
+      enum: ["single", "multiple", "cluster"],
+    })
+    .exec(async function (workspace, mode) {
+      await this.applicationScript.dbup(workspace, mode as "single" | "multiple" | "cluster");
+    }),
+  dbdown: target({ desc: "Stop local database services" })
+    .with(Workspace)
+    .exec(async function (workspace) {
+      await this.applicationScript.dbdown(workspace);
+    }),
+  configureApp: target({ desc: "Configure application settings interactively" })
+    .with(App)
+    .exec(async function (app) {
+      await this.applicationScript.configureApp(app);
+    }),
+})) {}

package/cli/application/application.interface.tsx

@@ -0,0 +1,225 @@
+"use client";
+import type { ChildProcess } from "node:child_process";
+import type EventEmitter from "node:events";
+import { type App as AppType, MultiScrollList, useStdoutDimensions } from "akanjs/devkit";
+import { Box, render, Text, useApp } from "ink";
+import type React from "react";
+import { useCallback, useEffect, useState } from "react";
+
+interface BackendProps {
+  appName: string;
+  childProcess: ChildProcess;
+  onExit: () => void;
+}
+
+const Backend = ({ appName, childProcess, onExit }: BackendProps) => {
+  const [width, height] = useStdoutDimensions();
+  useEffect(() => {
+
+    return () => {
+      childProcess.kill();
+      onExit();
+    };
+  }, [childProcess, onExit]);
+
+  return (
+    <Box width={width} height={height}>
+      <Text bold>Akan.JS Backend</Text>
+    </Box>
+  );
+};
+
+interface FrontendProps {
+  appName: string;
+  childProcess: ChildProcess;
+  onExit: () => void;
+}
+
+const Frontend = ({ appName, childProcess, onExit }: FrontendProps) => {
+  const [logs, setLogs] = useState<string[]>([]);
+  const [width, height] = useStdoutDimensions();
+
+  useEffect(() => {
+    childProcess.stdout?.on("data", (data: Buffer) => {
+      const newOutput = data.toString().split("\n");
+      setLogs((prevLogs) => [...prevLogs, ...newOutput]);
+    });
+    childProcess.stderr?.on("data", (data: Buffer) => {
+      const newOutput = data.toString().split("\n");
+      setLogs((prevLogs) => [...prevLogs, ...newOutput]);
+    });
+
+    return () => {
+      childProcess.kill();
+      onExit();
+    };
+  }, [childProcess, onExit]);
+
+  return (
+    <Box width={width} height={height} flexDirection="column">
+      <Text bold>{appName} Frontend</Text>
+      {logs.map((log) => (
+        <Text key={log}>{log}</Text>
+      ))}
+    </Box>
+  );
+};
+
+interface CsrProps {
+  app: AppType;
+  event: EventEmitter;
+  onExit: () => void;
+}
+
+const Csr = ({ app, event, onExit }: CsrProps) => {
+  const [logs, setLogs] = useState<string[]>([]);
+  const [width, height] = useStdoutDimensions();
+  useEffect(() => {
+    event.on("info", (msg: string) => {
+      setLogs((prevLogs) => [...prevLogs, msg]);
+    });
+    event.on("warn", (msg: string) => {
+      setLogs((prevLogs) => [...prevLogs, msg]);
+    });
+    event.on("warnOnce", (msg: string) => {
+      setLogs((prevLogs) => [...prevLogs, msg]);
+    });
+    event.on("error", (msg: string) => {
+      setLogs((prevLogs) => [...prevLogs, msg]);
+    });
+    event.on("clearScreen", (type: string) => {
+      setLogs((prevLogs) => [...prevLogs, type]);
+    });
+  }, [event]);
+  return (
+    <Box width={width} height={height} flexDirection="column">
+      <Text bold>Akan.JS CSR</Text>
+      <Text>{logs}</Text>
+    </Box>
+  );
+};
+
+const filterLogData = (data: Buffer | string) => {
+  return typeof data === "string"
+    ? data.split(/\r?\n/).filter((line) => line !== "")
+    : data
+        .toString()
+        .split(/\r?\n/)
+        .filter((line) => line !== "");
+};
+
+interface StartProps {
+  maxLength?: number;
+  appName: string;
+  bcp: ChildProcess;
+}
+
+/**
+ * Akan application 통합 실행 컴포넌트 (백엔드, 프론트엔드, React(CSR))
+ *
+ * @param maxLength 로그 최대 길이
+ * @param appName 앱 이름
+ * @param bcp 백엔드 차일드 프로세스
+ * @param onExit 종료 함수
+ */
+const Start = ({ appName, bcp, maxLength = 100 }: StartProps) => {
+  const [width, height] = useStdoutDimensions();
+  const [backendLogs, setBackendLogs] = useState<{ type: string; content: string }[]>([]);
+  const { exit } = useApp();
+
+  const saveLog = useCallback(
+    (
+      type: string,
+      data: Buffer | string,
+      setLog: React.Dispatch<React.SetStateAction<{ type: string; content: string }[]>>,
+    ) => {
+      const newOutput = filterLogData(data);
+      const logs = newOutput.map((line) => ({ type: type, content: line }));
+      setLog((currentLogs) => {
+        if (currentLogs.length >= maxLength) {
+          return [...currentLogs.slice(logs.length, maxLength), ...logs];
+        } else if (currentLogs.length < maxLength && currentLogs.length + logs.length > maxLength) {
+          return [...currentLogs.slice(Math.abs(maxLength - currentLogs.length - logs.length), maxLength), ...logs];
+        } else return [...currentLogs, ...logs];
+      });
+    },
+    [maxLength],
+  );
+
+  useEffect(() => {
+    bcp.stdout?.on("data", (data: Buffer) => {
+      saveLog("info", data, setBackendLogs);
+    });
+
+    bcp.stderr?.on("data", (data: Buffer) => {
+      saveLog("error", data, setBackendLogs);
+    });
+
+    return () => {
+      exit();
+    };
+  }, [bcp, saveLog, exit]);
+
+  return (
+    <Box borderColor="#ff493b" height={height} width={width} flexDirection="row">
+      <MultiScrollList
+        logList={[
+          {
+            title: `${appName} backend`,
+            logs: backendLogs,
+            color: "#e535ab",
+          },
+        ]}
+        maxLength={maxLength}
+      />
+    </Box>
+  );
+};
+
+export const Interface = {
+  /**
+   * Akan CSR 실행 컴포넌트
+   *
+   * @param app 앱 정보
+   * @param event CSR 이벤트 발생기
+   * @param onExit 종료 함수
+   */
+  Csr: (app: AppType, event: EventEmitter, onExit: () => void) =>
+    renderManager(<Csr app={app} event={event} onExit={onExit} />),
+  /**
+   * Akan Backend 실행 컴포넌트
+   *
+   * @param appName 앱 이름
+   * @param childProcess 백엔드 차일드 프로세스
+   * @param onExit 종료 함수
+   */
+  Backend: (appName: string, childProcess: ChildProcess, onExit: () => void) =>
+    renderManager(<Backend appName={appName} childProcess={childProcess} onExit={onExit} />),
+  /**
+   * Akan Frontend 실행 컴포넌트
+   *
+   * @param appName 앱 이름
+   * @param childProcess 프론트엔드 차일드 프로세스
+   * @param onExit 종료 함수
+   */
+  Frontend: (appName: string, childProcess: ChildProcess, onExit: () => void) =>
+    renderManager(<Frontend appName={appName} childProcess={childProcess} onExit={onExit} />),
+  /**
+   * Akan application 통합 실행 컴포넌트 (백엔드, 프론트엔드, React(CSR))
+   *
+   * @param maxLength 로그 최대 길이
+   * @param appName 앱 이름
+   * @param bcp 백엔드 차일드 프로세스
+   * @param fcp 프론트엔드 차일드 프로세스
+   * @param csr CSR 이벤트 발생기
+   * @param onExit 종료 함수
+   */
+  Start: (appName: string, bcp: ChildProcess) => renderManager(<Start appName={appName} bcp={bcp} />),
+};
+
+const renderManager = (component: React.ReactNode) => {
+
+  const renderFn = render(component);
+
+  return renderFn;
+};