@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/capacitorApp.ts

@@ -0,0 +1,440 @@
+import { cp, mkdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { MobileProject } from "@trapezedev/project";
+import type { AndroidProject } from "@trapezedev/project/dist/android/project";
+import type { IosProject } from "@trapezedev/project/dist/ios/project";
+import { capitalize } from "akanjs/common";
+import type { AkanMobileTargetConfig } from "./akanConfig";
+import type { AppExecutor } from "./executors";
+import { FileEditor } from "./fileEditor";
+import { resolveMobilePath, targetHtmlFilename } from "./mobile";
+
+interface RunConfig {
+  operation: "local" | "release";
+  env: "local" | "debug" | "develop" | "main";
+  regenerate?: boolean;
+}
+
+interface PrepareConfig extends RunConfig {}
+
+export class CapacitorApp {
+  project: MobileProject & { ios: IosProject; android: AndroidProject };
+  iosTargetName = "App";
+  readonly targetRoot: string;
+  readonly targetRootPath: string;
+  readonly targetWebRoot: string;
+  readonly targetAssetRoot: string;
+  readonly iosRootPath = "ios";
+  readonly iosProjectPath = "ios/App";
+  readonly androidRootPath = "android";
+  constructor(
+    private readonly app: AppExecutor,
+    readonly target: AkanMobileTargetConfig,
+  ) {
+    this.targetRootPath = path.posix.join("mobile", this.target.name);
+    this.targetRoot = path.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path.join(this.targetRoot, "www");
+    this.targetAssetRoot = path.join(this.targetRoot, "assets");
+    this.project = new MobileProject(this.app.cwdPath, {
+      android: { path: this.androidRootPath },
+      ios: { path: this.iosProjectPath },
+    }) as MobileProject & { ios: IosProject; android: AndroidProject };
+  }
+  async init({
+    platform,
+    operation = "release",
+    env = "debug",
+    regenerate = false,
+  }: { platform?: "ios" | "android" } & Partial<PrepareConfig> = {}) {
+    await mkdir(this.targetRoot, { recursive: true });
+    await this.#writeCapacitorConfig();
+    if (regenerate) {
+      if (!platform || platform === "ios")
+        await rm(path.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+      if (!platform || platform === "android")
+        await rm(path.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+    }
+    const project = this.project as MobileProject;
+    await this.project.load();
+    if ((!platform || platform === "android") && !project.android) {
+      await this.#spawnMobile("npx", ["cap", "add", "android"], { operation, env });
+      await this.project.load();
+    }
+    if ((!platform || platform === "ios") && !project.ios) {
+      await this.#spawnMobile("npx", ["cap", "add", "ios"], { operation, env });
+      await this.project.load();
+    }
+    return this;
+  }
+  async save() {
+    await this.project.commit();
+  }
+  async #prepareIos({ operation, env, regenerate = false }: PrepareConfig) {
+    await this.init({ platform: "ios", operation, env, regenerate });
+    await this.#prepareTargetAssets();
+    await this.#prepareExternalFiles("ios");
+    await this.#applyIosMetadata();
+    await this.#applyPermissions();
+    await this.#applyLinks();
+    await this.project.commit();
+    await this.#generateAssets({ operation, env });
+    this.app.verbose(`syncing iOS`);
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation, env });
+    this.app.verbose(`sync completed.`);
+  }
+  async buildIos({ env = "debug", regenerate = false }: { env?: RunConfig["env"]; regenerate?: boolean } = {}) {
+    await this.prepareWww();
+    await this.#prepareIos({ operation: "release", env, regenerate });
+    await this.#spawnMobile("npx", ["cap", "build", "ios"], { operation: "release", env }, { stdio: "inherit" });
+    this.app.verbose(`build completed iOS.`);
+    return;
+  }
+  async syncIos() {
+    await this.#spawnMobile("npx", ["cap", "sync", "ios"], { operation: "local", env: "local" });
+  }
+  async openIos() {
+    await this.#spawnMobile("npx", ["cap", "open", "ios"], { operation: "local", env: "local" });
+  }
+  async runIos({ operation, env, regenerate = false }: RunConfig) {
+    if (operation === "release") await this.prepareWww();
+    await this.#prepareIos({ operation, env, regenerate });
+    const args = ["cap", "run", "ios"];
+    await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
+  }
+
+  async #prepareAndroid({ operation, env, regenerate = false }: PrepareConfig) {
+    await this.init({ platform: "android", operation, env, regenerate });
+    await this.#prepareTargetAssets();
+    await this.#prepareExternalFiles("android");
+    await this.#applyAndroidMetadata();
+    await this.#applyPermissions();
+    await this.#applyLinks();
+    await this.project.commit();
+    await this.#generateAssets({ operation, env });
+    await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
+  }
+
+  async #updateAndroidBuildTypes() {
+    //keystore 기본 설정 및 debug, release 설정
+
+    const appGradle = await FileEditor.create(path.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const buildTypesBlock = `
+      debug {
+        applicationIdSuffix ".debug"
+        versionNameSuffix "-DEBUG"
+        debuggable true
+        minifyEnabled false
+      }
+    `;
+    const singinConfigBlock = `
+     signingConfigs {
+        debug {
+            storeFile file('debug.keystore')
+            storePassword 'android'
+            keyAlias 'androiddebugkey'
+            keyPassword 'android'
+        }
+        release {
+            if (project.hasProperty('MYAPP_RELEASE_STORE_FILE')) {
+                storeFile file(MYAPP_RELEASE_STORE_FILE)
+                storePassword MYAPP_RELEASE_STORE_PASSWORD
+                keyAlias MYAPP_RELEASE_KEY_ALIAS
+                keyPassword MYAPP_RELEASE_KEY_PASSWORD
+            }
+        }
+    }
+        `;
+    if (appGradle.find("signingConfigs {") === -1) {
+      appGradle.insertBefore("buildTypes {", singinConfigBlock);
+    }
+    if (appGradle.find(`applicationIdSuffix ".debug"`) === -1) {
+      appGradle.insertAfter("buildTypes {", buildTypesBlock);
+    }
+    await appGradle.save();
+  }
+  async buildAndroid(
+    assembleType: "apk" | "aab",
+    { env = "debug", regenerate = false }: { env?: RunConfig["env"]; regenerate?: boolean } = {},
+  ) {
+    await this.prepareWww();
+    await this.#prepareAndroid({ operation: "release", env, regenerate });
+    await this.#updateAndroidBuildTypes();
+    //윈도우는 gradlew.bat 사용
+    const isWindows = process.platform === "win32";
+    const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
+
+    await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
+      stdio: "inherit",
+      cwd: path.join(this.app.cwdPath, this.androidRootPath),
+      env: this.#commandEnv("release", env),
+    });
+  }
+  async openAndroid() {
+    await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
+  }
+  async syncAndroid(options: { regenerate?: boolean } = {}) {
+    await this.prepareWww();
+    await this.#prepareAndroid({ operation: "release", env: "debug", ...options });
+    this.app.log(`Sync Android Completed.`);
+  }
+  async runAndroid({ operation, env, regenerate = false }: RunConfig) {
+    if (operation === "release") await this.prepareWww();
+    await this.#prepareAndroid({ operation, env, regenerate });
+    this.app.logger.info(`Running Android in ${operation} mode on ${env} env`);
+    const args = ["cap", "run", "android"];
+    await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
+  }
+
+  async releaseIos() {
+    await this.prepareWww();
+    await this.#prepareIos({ operation: "release", env: "main" });
+  }
+  async releaseAndroid() {
+    await this.prepareWww();
+    await this.#prepareAndroid({ operation: "release", env: "main" });
+  }
+  async prepareWww() {
+    const htmlSource = path.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    if (!(await Bun.file(htmlSource).exists()))
+      throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
+    await rm(this.targetWebRoot, { recursive: true, force: true });
+    await mkdir(this.targetWebRoot, { recursive: true });
+    await Bun.write(
+      path.join(this.targetWebRoot, "index.html"),
+      this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()),
+    );
+  }
+  #injectMobileTargetMeta(html: string) {
+    const basePath = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
+    const script = `<script>window.__AKAN_MOBILE_TARGET__=${JSON.stringify({ name: this.target.name, basePath })};</script>`;
+    if (html.includes("window.__AKAN_MOBILE_TARGET__")) return html;
+    return html.replace(/<\/head\s*>/i, `${script}\n</head>`);
+  }
+  async #writeCapacitorConfig() {
+    await mkdir(this.targetRoot, { recursive: true });
+    const appInfoPath = path
+      .relative(this.app.cwdPath, path.join(this.app.cwdPath, "akan.app.json"))
+      .split(path.sep)
+      .join("/");
+    const content = `import type { AppScanResult } from "akanjs";
+import { withBase } from "@akanjs/devkit/capacitor.base.config";
+import appInfo from "${appInfoPath.startsWith(".") ? appInfoPath : `./${appInfoPath}`}";
+
+export default withBase(
+  (config, target) => ({
+    ...config,
+    webDir: \`mobile/\${target.name}/www\`,
+    android: {
+      ...config.android,
+      path: "android",
+    },
+    ios: {
+      ...config.ios,
+      path: "ios",
+    },
+  }),
+  appInfo as AppScanResult,
+);
+`;
+    await Bun.write(path.join(this.app.cwdPath, "capacitor.config.ts"), content);
+  }
+  async #prepareTargetAssets() {
+    if (!this.target.assets) return;
+    await mkdir(this.targetAssetRoot, { recursive: true });
+    if (this.target.assets.icon)
+      await cp(path.join(this.app.cwdPath, this.target.assets.icon), path.join(this.targetAssetRoot, "icon.png"), {
+        force: true,
+      });
+    if (this.target.assets.splash)
+      await cp(path.join(this.app.cwdPath, this.target.assets.splash), path.join(this.targetAssetRoot, "splash.png"), {
+        force: true,
+      });
+  }
+  async #prepareExternalFiles(platform: "ios" | "android") {
+    const files = this.target.files?.[platform];
+    if (!files) return;
+    const platformRoot = path.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    await Promise.all(
+      Object.entries(files).map(async ([to, from]) => {
+        const targetPath = path.join(platformRoot, to);
+        await mkdir(path.dirname(targetPath), { recursive: true });
+        await cp(path.join(this.app.cwdPath, from), targetPath, { force: true });
+      }),
+    );
+  }
+  async #generateAssets({ operation, env }: Pick<RunConfig, "operation" | "env">) {
+    if (!this.target.assets) return;
+    await this.#spawnMobile(
+      "npx",
+      [
+        "@capacitor/assets",
+        "generate",
+        "--assetPath",
+        path.posix.join(this.targetRootPath, "assets"),
+        "--iosProject",
+        this.iosProjectPath,
+        "--androidProject",
+        this.androidRootPath,
+      ],
+      { operation, env },
+    );
+  }
+  async #applyIosMetadata() {
+    this.project.ios.setBundleId("App", "Debug", this.target.appId);
+    this.project.ios.setBundleId("App", "Release", this.target.appId);
+    await this.project.ios.setVersion("App", "Debug", this.target.version);
+    await this.project.ios.setVersion("App", "Release", this.target.version);
+    await this.project.ios.setBuild("App", "Debug", this.target.buildNum);
+    await this.project.ios.setBuild("App", "Release", this.target.buildNum);
+  }
+  async #applyAndroidMetadata() {
+    await this.project.android.setVersionName(this.target.version);
+    await this.project.android.setPackageName(this.target.appId);
+    await this.project.android.setVersionCode(this.target.buildNum);
+    await this.project.android.setAppName(this.target.appName);
+  }
+  async #applyPermissions() {
+    for (const permission of this.target.permissions ?? []) {
+      if (permission === "camera") await this.addCamera();
+      else if (permission === "contacts") await this.addContact();
+      else if (permission === "location") await this.addLocation();
+      else if (permission === "push") await this.addPush();
+    }
+  }
+  async #applyLinks() {
+    const links = this.target.links;
+    if (!links) return;
+    const schemes = links.schemes ?? [];
+    if (schemes.length > 0) {
+      await this.#setPermissionInIos({
+        appTransportSecurity: "",
+      });
+      for (const scheme of schemes) {
+        this.project.android
+          .getAndroidManifest()
+          .injectFragment(
+            "activity",
+            `<intent-filter><action android:name="android.intent.action.VIEW" /><category android:name="android.intent.category.DEFAULT" /><category android:name="android.intent.category.BROWSABLE" /><data android:scheme="${scheme}" /></intent-filter>`,
+          );
+      }
+    }
+    for (const domain of links.associatedDomains ?? []) {
+      this.app.logger.info(`Configure iOS associated domain manually if needed: ${domain}`);
+    }
+    for (const host of links.androidHosts ?? []) {
+      const pathPrefix = resolveMobilePath(this.target, "/");
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment(
+          "activity",
+          `<intent-filter android:autoVerify="true"><action android:name="android.intent.action.VIEW" /><category android:name="android.intent.category.DEFAULT" /><category android:name="android.intent.category.BROWSABLE" /><data android:scheme="https" android:host="${host}" android:pathPrefix="${pathPrefix}" /></intent-filter>`,
+        );
+    }
+  }
+  #commandEnv(operation: "local" | "release", env: "local" | "debug" | "develop" | "main") {
+    return this.app.getCommandEnv({
+      APP_OPERATION_MODE: operation,
+      AKAN_PUBLIC_OPERATION_MODE: env === "local" ? "local" : "cloud",
+      AKAN_PUBLIC_ENV: env,
+      AKAN_MOBILE_TARGET: this.target.name,
+    });
+  }
+  async #spawn(command: string, args: string[] = [], options: Parameters<AppExecutor["spawn"]>[2] = {}) {
+    return await this.app.spawn(command, args, { cwd: this.app.cwdPath, ...options });
+  }
+  async #spawnMobile(
+    command: string,
+    args: string[] = [],
+    { operation, env }: Pick<RunConfig, "operation" | "env">,
+    options: Parameters<AppExecutor["spawn"]>[2] = {},
+  ) {
+    return await this.#spawn(command, args, {
+      ...options,
+      env: { ...this.#commandEnv(operation, env), ...options.env },
+    });
+  }
+  async addCamera() {
+    await this.#setPermissionInIos({
+      cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
+      photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+      photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+    });
+    this.#setPermissionsInAndroid(["READ_MEDIA_IMAGES", "READ_EXTERNAL_STORAGE", "WRITE_EXTERNAL_STORAGE"]);
+  }
+  async addContact() {
+    await this.#setPermissionInIos({
+      contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to add new contacts.",
+    });
+    this.#setPermissionsInAndroid(["READ_CONTACTS", "WRITE_CONTACTS"]);
+  }
+  async addLocation() {
+    await this.#setPermissionInIos({
+      locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+      locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+    });
+    this.#setPermissionsInAndroid(["ACCESS_COARSE_LOCATION", "ACCESS_FINE_LOCATION"]);
+    this.#setFeaturesInAndroid(["android.hardware.location.gps"]);
+  }
+  async addPush() {
+    await this.#setPermissionInIos({
+      userNotificationsUsageDescription: "$(PRODUCT_NAME) uses notifications to keep you updated.",
+    });
+    this.#setPermissionsInAndroid(["POST_NOTIFICATIONS"]);
+  }
+  async #setPermissionInIos(permissions: { [key: string]: string }) {
+    const updateNs = Object.fromEntries(
+      Object.entries(permissions).map(([key, value]) => [`NS${capitalize(key)}`, value]),
+    );
+    await Promise.all([
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
+      this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs),
+    ]);
+  }
+  #setFeaturesInAndroid(features: string[]) {
+    for (const feature of features) {
+      if (this.#hasFeatureInAndroid(feature)) {
+        this.app.logger.info(`${feature} already exists in android`);
+        return this;
+      }
+      this.app.logger.info(`Adding ${feature} to android`);
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment("manifest", `<uses-feature android:name="${feature}" />`);
+    }
+    return this;
+  }
+  #getFeaturesInAndroid() {
+    const androidManifest = this.project.android.getAndroidManifest();
+    const element = androidManifest.getDocumentElement();
+    if (!element) throw new Error("manifest not found");
+    const usesFeature = element.getElementsByTagName("uses-feature");
+    return Array.from(usesFeature).map((feature) => feature.getAttribute("android:name"));
+  }
+  #hasFeatureInAndroid(feature: string) {
+    return this.#getFeaturesInAndroid().includes(feature);
+  }
+
+  #setPermissionsInAndroid(permissions: string[]) {
+    for (const permission of permissions) {
+      if (this.#hasPermissionInAndroid(permission)) {
+        this.app.logger.info(`${permission} already exists in android`);
+        return this;
+      }
+      this.app.logger.info(`Adding ${permission} to android`);
+      this.project.android
+        .getAndroidManifest()
+        .injectFragment("manifest", `<uses-permission android:name="android.permission.${permission}" />`);
+    }
+    return this;
+  }
+  #getPermissionsInAndroid() {
+    const androidManifest = this.project.android.getAndroidManifest();
+    const element = androidManifest.getDocumentElement();
+    if (!element) throw new Error("manifest not found");
+    const usesPermission = element.getElementsByTagName("uses-permission");
+    return Array.from(usesPermission).map((permission) => permission.getAttribute("android:name"));
+  }
+  #hasPermissionInAndroid(permission: string) {
+    return this.#getPermissionsInAndroid().includes(permission);
+  }
+}

package/commandDecorators/argMeta.ts

@@ -0,0 +1,102 @@
+import type {
+  AppExecutor,
+  Executor,
+  LibExecutor,
+  ModuleExecutor,
+  PkgExecutor,
+  SysExecutor,
+  WorkspaceExecutor,
+} from "../executors";
+import { COMMAND_META, type CommandCls } from "./targetMeta";
+
+export const argTypes = ["Argument", "Option"] as const;
+export type ArgType = (typeof argTypes)[number];
+
+export const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg", "Module", "Exec"] as const;
+export type InternalArgType = (typeof internalArgTypes)[number];
+
+export type PrimitiveArgType = StringConstructor | NumberConstructor | BooleanConstructor;
+export type NormalizedPrimitiveArgType = "string" | "number" | "boolean";
+
+export type CommandContext = {
+  values: Record<string, unknown>;
+  app?: AppExecutor;
+  lib?: LibExecutor;
+  sys?: SysExecutor;
+  pkg?: PkgExecutor;
+  module?: ModuleExecutor;
+  exec?: Executor;
+};
+
+export type EnumChoice = string | number | { label: string; value: string | number | boolean };
+export type EnumChoices = readonly EnumChoice[];
+export type DynamicEnum<Context> = (context: Context) => EnumChoices | Promise<EnumChoices>;
+
+export interface ArgsOption<Context = CommandContext> {
+  type?: "string" | "number" | "boolean";
+  flag?: string;
+  desc?: string;
+  default?: string | number | boolean;
+  nullable?: boolean;
+  example?: string | number | boolean;
+  enum?: EnumChoices | DynamicEnum<Context>;
+  ask?: string;
+}
+export interface ArgMeta<Context = CommandContext> {
+  name: string;
+  argsOption: ArgsOption<Context>;
+  key: string;
+  idx: number;
+  type: ArgType;
+}
+export interface InternalArgMeta {
+  key: string;
+  idx: number;
+  type: InternalArgType;
+  option?: { nullable?: boolean };
+}
+
+export const getArgMetas = (
+  command: CommandCls,
+  key: string,
+): [(ArgMeta | InternalArgMeta)[], ArgMeta[], (ArgMeta | InternalArgMeta)[]] => {
+  const allArgMetas = [...(command[COMMAND_META]?.get(key)?.args ?? [])];
+  const argMetas = allArgMetas.filter((argMeta): argMeta is ArgMeta => argMeta.type === "Option");
+  const internalArgMetas = allArgMetas.filter((argMeta) => argMeta.type !== "Option");
+  return [allArgMetas, argMetas, internalArgMetas];
+};
+
+export interface InternalArgToken<T = unknown, Type extends InternalArgType = InternalArgType> {
+  type: Type;
+  _value: T;
+}
+
+const createInternalArgToken = <T, Type extends InternalArgType>(type: Type) => ({ type }) as InternalArgToken<T, Type>;
+
+export const normalizePrimitiveArgType = (type: PrimitiveArgType): NormalizedPrimitiveArgType => {
+  if (type === String) return "string";
+  if (type === Number) return "number";
+  if (type === Boolean) return "boolean";
+  throw new Error(`Invalid primitive argument type: ${type}`);
+};
+
+export const App = createInternalArgToken<AppExecutor, "App">("App");
+export type App = AppExecutor;
+
+export const Lib = createInternalArgToken<LibExecutor, "Lib">("Lib");
+export type Lib = LibExecutor;
+
+export const Sys = createInternalArgToken<SysExecutor, "Sys">("Sys");
+export type Sys = SysExecutor;
+
+export const Exec = createInternalArgToken<Executor, "Exec">("Exec");
+export type Exec = Executor;
+
+export const Pkg = createInternalArgToken<PkgExecutor, "Pkg">("Pkg");
+export type Pkg = PkgExecutor;
+
+export const Module = createInternalArgToken<ModuleExecutor, "Module">("Module");
+export type Module = ModuleExecutor;
+
+export const Workspace = createInternalArgToken<WorkspaceExecutor, "Workspace">("Workspace");
+export type Workspace = WorkspaceExecutor;