akanjs 2.0.7 → 2.1.0-rc.0

package/types/document/index.d.ts

@@ -3,7 +3,7 @@ export * from "./database.d.ts";
 export * from "./databaseRegistry.d.ts";
 export * from "./dataLoader.d.ts";
 export * from "./documentQuery.d.ts";
-export * from "./documentSchema";
+export * from "./documentSchema.d.ts";
 export * from "./filterMeta.d.ts";
 export * from "./into.d.ts";
 export * from "./loaderInfo.d.ts";

package/types/document/schema.d.ts

@@ -1,4 +1,4 @@
-import { DocumentSchema } from "./documentSchema";
+import { DocumentSchema } from "./documentSchema.d.ts";
 export declare const getDefaultSchemaOptions: <TSchema, TDocument>() => DocumentSchema<TDocument>;
 export declare const convertAggregateMatch: (query: unknown) => {
     [k: string]: unknown;

package/types/document/types.d.ts

@@ -33,4 +33,4 @@ export interface FindQueryOption<Sort = never, Obj = any> {
     sample?: boolean;
     select?: Partial<Record<keyof Obj, boolean>>;
 }
-export type { SchemaOf } from "./documentSchema";
+export type { SchemaOf } from "./documentSchema.d.ts";

package/types/{devkit/akanConfig/types.d.ts → index.d.ts}

@@ -1,135 +1,99 @@
-import type { CapacitorConfig } from "@capacitor/cli";
 import type { AkanI18nConfig } from "akanjs/common";
 import type { AkanImageConfig } from "akanjs/server";
-import type { App, Lib } from "../commandDecorators.d.ts";
 export declare const archs: readonly ["amd64", "arm64"];
-/** CPU architecture names supported by architecture-specific Docker settings. */
 export type Arch = (typeof archs)[number];
 export interface DockerConfig {
-    /** Full Dockerfile content. When set, Akan uses it instead of composing the default Dockerfile. */
     content: string;
-    /** Base Docker image, either shared for all architectures or mapped by target architecture. */
     image: string | {
         [key in Arch]?: string;
     };
-    /** Shell commands inserted before app files are copied into the generated Dockerfile. */
     preRuns: (string | {
         [key in Arch]?: string;
     })[];
-    /** Shell commands inserted after production dependencies are installed in the generated Dockerfile. */
     postRuns: (string | {
         [key in Arch]?: string;
     })[];
-    /** Container startup command written to the generated Dockerfile CMD instruction. */
     command: string[];
 }
 export interface AkanRouteDomains {
-    /** Production branch domains. */
     main?: string[];
-    /** Develop branch domains. */
     develop?: string[];
-    /** Debug branch domains. */
     debug?: string[];
-    /** Additional branch-specific domains keyed by branch name. */
     [branch: string]: string[] | undefined;
 }
 export interface AkanRouteConfig {
-    /** Optional URL base path served by this route, such as "shop" for /shop. */
     basePath?: string;
-    /** Domains grouped by branch name for this route. */
     domains: AkanRouteDomains;
 }
-/** Default database topology used by database-aware commands and runtime setup. */
 export type DatabaseMode = "single" | "multiple" | "cluster";
-/** Environment names used when producing mobile builds. */
 export type MobileEnv = "local" | "debug" | "develop" | "main";
-/** Native device permissions that can be requested by a mobile target. */
 export type MobilePermission = "camera" | "contacts" | "location" | "push";
 export interface AkanMobileTargetAssets {
-    /** Path to the icon asset used for this native target. */
     icon?: string;
-    /** Path to the splash screen asset used for this native target. */
     splash?: string;
 }
 export interface AkanMobileTargetLinks {
-    /** Custom URL schemes handled by this native target. */
     schemes?: string[];
-    /** iOS associated domains used for universal links. */
     associatedDomains?: string[];
-    /** Android hosts used for app links. */
     androidHosts?: string[];
 }
 export interface AkanMobileTargetFiles {
-    /** Extra iOS files copied into the native project, keyed by destination path. */
     ios?: Record<string, string>;
-    /** Extra Android files copied into the native project, keyed by destination path. */
     android?: Record<string, string>;
 }
-export interface AkanMobileTargetConfig extends CapacitorConfig {
-    /** Target name used by Akan mobile commands. */
+export interface AkanCapacitorLikeConfig {
+    plugins?: Record<string, unknown>;
+    android?: Record<string, unknown>;
+    ios?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface AkanMobileTargetConfig extends AkanCapacitorLikeConfig {
     name: string;
-    /** Route base path this native target should open. Must match a configured route basePath when set. */
     basePath?: string;
-    /** Display name for this native target. */
     appName: string;
-    /** Native application identifier, such as com.example.app. */
     appId: string;
-    /** Native app version string. */
     version: string;
-    /** Native build number. */
     buildNum: number;
-    /** Icon and splash assets for this target. */
     assets?: AkanMobileTargetAssets;
-    /** Device permissions requested by this target. */
     permissions?: MobilePermission[];
-    /** Deep link and universal/app link settings for this target. */
     links?: AkanMobileTargetLinks;
-    /** Extra files copied into native platform projects for this target. */
     files?: AkanMobileTargetFiles;
 }
-export interface AkanMobileConfig extends CapacitorConfig {
-    /** Default display name used by mobile targets. */
+export interface AkanMobileConfig extends AkanCapacitorLikeConfig {
     appName: string;
-    /** Default native application identifier used by mobile targets. */
     appId: string;
-    /** Default native app version used by mobile targets. */
     version: string;
-    /** Default native build number used by mobile targets. */
     buildNum: number;
-    /** Named native build targets, usually mapped to route base paths or app variants. */
     targets: Record<string, AkanMobileTargetConfig>;
 }
 export interface AppConfigResult {
-    /** Customizes the production Dockerfile content, base image, run scripts, and startup command. */
     docker: DockerConfig;
-    /** Selects the default database deployment mode used by database-aware commands and runtime setup. */
     defaultDatabaseMode: DatabaseMode;
-    /** Maps app domains and optional base paths for multi-domain or multi-client routing. */
     routes?: AkanRouteConfig[];
-    /** Lists runtime dependencies that should be preserved in the generated production package. */
     externalLibs: string[];
-    /** Adds custom barrel import roots to Akan's default framework, app, and library facets. */
     barrelImports: string[];
-    /** Adds packages or import roots that should participate in optimized import handling. */
     optimizeImports: string[];
-    /** Configures optimized image sizes, formats, allowed sources, cache, timeout, and byte limits. */
     images: AkanImageConfig;
-    /** Defines supported locales and the default locale exposed through Akan public locale env values. */
     i18n: AkanI18nConfig;
-    /** Allows selected environment keys to be exposed to browser-side code. */
     publicEnv: string[];
-    /** Defines native app identity, versions, targets, permissions, assets, links, and Capacitor options. */
     mobile: AkanMobileConfig;
 }
 export interface LibConfigResult {
-    /** Lists runtime dependencies that should be preserved when a library requires external packages. */
     externalLibs: string[];
 }
 export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends unknown[] ? T[P] : T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
-export type AppConfig = DeepPartial<AppConfigResult> | ((app: App) => DeepPartial<AppConfigResult>);
-export type LibConfig = DeepPartial<LibConfigResult> | ((lib: Lib) => DeepPartial<LibConfigResult>);
+export interface AppConfigContext {
+    readonly name: string;
+    readonly type: "app";
+}
+export interface LibConfigContext {
+    readonly name: string;
+    readonly type: "lib";
+}
+export type AppConfig = DeepPartial<AppConfigResult> | ((app: AppConfigContext) => DeepPartial<AppConfigResult>);
+export type LibConfig = DeepPartial<LibConfigResult> | ((lib: LibConfigContext) => DeepPartial<LibConfigResult>);
 export type AkanConfigFile = object;
 export interface FileConventionScanResult {
     constant: {
@@ -220,3 +184,30 @@ export interface WorkspaceScanResult {
         [key: string]: PkgScanResult;
     };
 }
+export interface AppInfo {
+    readonly name: string;
+    readonly type: "app";
+    readonly database: Map<string, Set<string>>;
+    readonly service: Map<string, Set<string>>;
+    readonly scalar: Map<string, Set<string>>;
+    readonly file: FileConventionScanResult;
+    getLibs(): string[];
+    getLibInfos(): Map<string, LibInfo>;
+    getDatabaseModules(): string[];
+    getScalarModules(): string[];
+    getServiceModules(): string[];
+}
+export interface LibInfo {
+    readonly name: string;
+    readonly type: "lib";
+    readonly database: Map<string, Set<string>>;
+    readonly service: Map<string, Set<string>>;
+    readonly scalar: Map<string, Set<string>>;
+    readonly file: FileConventionScanResult;
+    getLibs(): string[];
+    getLibInfos(): Map<string, LibInfo>;
+    getLibInfo(libName: string): LibInfo | undefined;
+    getDatabaseModules(): string[];
+    getScalarModules(): string[];
+    getServiceModules(): string[];
+}

package/types/server/akanAppHeaders.d.ts

@@ -0,0 +1 @@
+export declare function makeAkanChildProxyHeaders(req: Request, childIdx: number): Headers;

package/types/server/di/predefinedAdaptor.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseMode } from "akanjs/base";
+import type { DatabaseMode } from "akanjs";
 import { type AdaptorCls, BlobStorage, type CacheAdaptor, type CompressAdaptor, ConsoleLogger, type DatabaseAdaptor, type LoggingAdaptor, ProtobufCompressor, type QueueAdaptor, type ScheduleAdaptor, Scheduler, SolidCache, SolidPubSub, SolidQueue, SqliteDatabase, type StorageAdaptor, type WebsocketAdaptor } from "akanjs/service";
 export interface PredefinedAdaptor {
     database: AdaptorCls<DatabaseAdaptor>;

package/types/store/baseSt.d.ts

@@ -249,7 +249,7 @@ export declare const st: {
         innerWidth: () => number;
         innerHeight: () => number;
         responsive: () => "xl" | "lg" | "md" | "sm" | "xs";
-        uiOperation: () => "sleep" | "idle" | "loading";
+        uiOperation: () => "loading" | "sleep" | "idle";
         messages: () => {
             type: "info" | "success" | "error" | "warning" | "loading";
             content: string;
@@ -280,7 +280,7 @@ export declare const st: {
         setInnerWidth: (value: number) => void;
         setInnerHeight: (value: number) => void;
         setResponsive: (value: "xl" | "lg" | "md" | "sm" | "xs") => void;
-        setUiOperation: (value: "sleep" | "idle" | "loading") => void;
+        setUiOperation: (value: "loading" | "sleep" | "idle") => void;
         setMessages: (value: {
             type: "info" | "success" | "error" | "warning" | "loading";
             content: string;

package/ui/Link/SsrLink.tsx

@@ -63,8 +63,8 @@ export default function SsrLink({
         try {
           Logger.log(`pathChange-start:${requestHref}`);
           window.parent.postMessage({ type: "pathChange", href: requestHref }, "*");
-          if (replace) router.replace(requestHref, { scrollToTop });
-          else router.push(requestHref, { scrollToTop });
+          if (replace) router.replace(href, { scrollToTop });
+          else router.push(href, { scrollToTop });
         } catch (error) {
           Logger.warn(`SSR link navigation failed, falling back to document navigation: ${String(error)}`);
           if (replace) window.location.replace(requestHref);

package/webkit/useCodepush.tsx

@@ -61,7 +61,7 @@ export const useCodepush = ({ serverUrl }: { serverUrl: string }) => {
       buildNum: app.build, //앱내 빌드시 버전 횟수 모르면 고한테 물어보기
       versionOs: info.osVersion,
     };
-    
+
     const url = serverUrl.replace("lu", "akasys");
     const httpClient = new HttpClient(url);
     const release = await httpClient.post<(ProtoAppInfo & { appBuild: string }) | null>("/release/codepush", {

package/cli/application/application.command.ts

@@ -1,224 +0,0 @@
-import { select } from "@inquirer/prompts";
-import { App, command, Exec, getMobileTargetChoices, 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",
-      ask: "Select mobile target",
-      enum: async ({ app }) => await getMobileTargetChoices(app),
-    })
-    .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",
-      ask: "Select mobile target",
-      enum: async ({ app }) => await getMobileTargetChoices(app),
-    })
-    .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, {
-      ask: "Select mobile target",
-      enum: async ({ app }) => await getMobileTargetChoices(app),
-    })
-    .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);
-    }),
-})) {}