akanjs 2.4.2-rc.1 → 2.4.2-rc.2

package/common/index.ts

@@ -52,7 +52,7 @@ export {
 } from "./routeConvention";
 export { sleep } from "./sleep";
 export { splitVersion } from "./splitVersion";
-export { getBasePathFromPathname, parseBasePaths } from "./subRoute";
+export { getBasePathFromPathname, parseBasePaths, parseSubRouteHosts, resolveSubRouteHosts } from "./subRoute";
 export type * from "./types";
 export {
   type WebsocketAuthAckData,

package/common/subRoute.ts

@@ -12,6 +12,67 @@ export const parseBasePaths = (value: string | string[] | Set<string> | undefine
   return [...new Set(items.map((basePath) => basePath.trim()).filter(Boolean))];
 };
 
+const normalizeSubRouteHost = (host: string): string => host.trim().toLowerCase().replace(/:\d+$/, "");
+
+/** A hostname never contains these; a fragment carrying one is a malformed entry, not a host we failed to match. */
+const isSubRouteHost = (host: string): boolean => host.length > 0 && !/[\s/=]/.test(host);
+
+/**
+ * `"soft=a.com,b.com;office=c.com"` -> `{ soft: ["a.com", "b.com"], office: ["c.com"] }`. A deployment platform
+ * renders this value, so a malformed entry is skipped rather than thrown: one bad character must not CrashLoop
+ * every pod that received it.
+ */
+export const parseSubRouteHosts = (value: string | undefined | null): Record<string, string[]> => {
+  const hostsByBasePath: Record<string, string[]> = {};
+  for (const group of (value ?? "").split(";")) {
+    const separatorIdx = group.indexOf("=");
+    if (separatorIdx < 0) continue;
+    const basePath = group
+      .slice(0, separatorIdx)
+      .trim()
+      .replace(/^\/+|\/+$/g, "");
+    if (!basePath) continue;
+    const hosts = group
+      .slice(separatorIdx + 1)
+      .split(",")
+      .map(normalizeSubRouteHost)
+      .filter(isSubRouteHost);
+    if (!hosts.length) continue;
+    hostsByBasePath[basePath] = [...new Set([...(hostsByBasePath[basePath] ?? []), ...hosts])];
+  }
+  return hostsByBasePath;
+};
+
+/**
+ * Unions the env mapping onto the one baked into the build artifact, never replacing it — dropping the env is the
+ * rollback path. A basePath the build does not serve is reported back instead of honoured: the route tree is a
+ * build output, so accepting one would answer every request under it with a 404 and nothing to explain why.
+ */
+export const resolveSubRouteHosts = ({
+  subRoutes,
+  basePaths,
+  env,
+}: {
+  subRoutes: Record<string, string[]>;
+  basePaths: Iterable<string>;
+  env?: string | null;
+}): { subRoutes: Record<string, string[]>; ignoredBasePaths: string[] } => {
+  const parsed = Object.entries(parseSubRouteHosts(env));
+  if (!parsed.length) return { subRoutes, ignoredBasePaths: [] };
+
+  const configuredBasePaths = new Set(parseBasePaths([...basePaths]));
+  const merged: Record<string, string[]> = { ...subRoutes };
+  const ignoredBasePaths: string[] = [];
+  for (const [basePath, hosts] of parsed) {
+    if (!configuredBasePaths.has(basePath)) {
+      ignoredBasePaths.push(basePath);
+      continue;
+    }
+    merged[basePath] = [...new Set([...(merged[basePath] ?? []).map(normalizeSubRouteHost), ...hosts])];
+  }
+  return { subRoutes: merged, ignoredBasePaths };
+};
+
 export const getBasePathFromPathname = (
   pathname: string,
   {

package/constant/cascadePaths.ts

@@ -0,0 +1,32 @@
+import type { ConstantField, FieldObject } from "./fieldInfo";
+import type { ConstantModelRef } from "./via";
+
+/** What happens to the documents a relation field points at when the owner is removed. */
+export const cascadeActions = ["remove"] as const;
+export type CascadeAction = (typeof cascadeActions)[number];
+
+export class CascadePaths {
+  /** Field key → the model its ids point at. Resolved to a refName later: the target may not be registered yet. */
+  readonly remove = new Map<string, ConstantModelRef>();
+
+  collect(fieldMap: FieldObject) {
+    for (const [key, field] of Object.entries(fieldMap)) {
+      if (!field.cascade) continue;
+      this.#assertCascadable(key, field.cascade, field);
+      this.remove.set(key, field.modelRef);
+    }
+    return this;
+  }
+
+  #assertCascadable(key: string, action: CascadeAction, field: ConstantField) {
+    
+    if (!cascadeActions.includes(action)) {
+      throw new Error(`Cascade field "${key}" declares cascade: "${action}", which is not one of ${cascadeActions}`);
+    }
+    
+    if (!field.isClass || field.isScalar) {
+      throw new Error(`Cascade field "${key}" is not a model reference and has no document to remove`);
+    }
+    if (field.arrDepth > 1) throw new Error(`Cascade field "${key}" is a nested array and cannot cascade`);
+  }
+}

package/constant/fieldInfo.ts

@@ -16,6 +16,7 @@ import {
   type SingleValue,
   type UnCls,
 } from "akanjs/base";
+import type { CascadeAction } from "./cascadePaths";
 import { ConstantRegistry } from "./constantRegistry";
 import type { TextFieldRole } from "./textFieldPaths";
 import type { BaseObject } from "./types";
@@ -104,6 +105,7 @@ export interface ConstantFieldProps<
   of?: MapValue; 
   validate?: (value: FieldValue, model: any) => boolean;
   text?: TextFieldRole;
+  cascade?: CascadeAction;
   meta?: Metadata;
 }
 export const fieldPresets = ["email", "password", "url"] as const;
@@ -194,6 +196,7 @@ interface ConstantFieldBuildProps<
   of?: MapValue; 
   validate?: (value: FieldValue, model: any) => boolean;
   text?: TextFieldRole;
+  cascade?: CascadeAction;
   modelRef: ConstantModelRef;
   arrDepth: number;
   optArrDepth: number;
@@ -317,6 +320,7 @@ export class ConstantField<
   readonly of?: MapValue; 
   readonly validate?: (value: FieldValue, model: any) => boolean;
   readonly text?: TextFieldRole;
+  readonly cascade?: CascadeAction;
   readonly modelRef: ConstantModelRef;
   readonly arrDepth: number;
   readonly optArrDepth: number;
@@ -348,6 +352,7 @@ export class ConstantField<
     this.of = props.of;
     this.validate = props.validate;
     this.text = props.text;
+    this.cascade = props.cascade;
     this.modelRef = props.modelRef;
     this.arrDepth = props.arrDepth;
     this.optArrDepth = props.optArrDepth;
@@ -426,6 +431,7 @@ export class ConstantField<
       of: option.of,
       validate: option.validate,
       text: option.text,
+      cascade: option.cascade,
       modelRef,
       arrDepth: arrDepth,
       optArrDepth: optArrDepth,
@@ -465,6 +471,7 @@ export class ConstantField<
       of: this.of,
       validate: this.validate,
       text: this.text,
+      cascade: this.cascade,
       modelRef: this.modelRef,
       arrDepth: this.arrDepth,
       optArrDepth: this.optArrDepth,

package/constant/index.ts

@@ -1,3 +1,4 @@
+export * from "./cascadePaths";
 export * from "./constantRegistry";
 export * from "./crystalize";
 export * from "./deserialize";

package/constant/via.ts

@@ -13,6 +13,7 @@ import { applyMixins } from "akanjs/common";
 import { immerable } from "immer";
 
 import { crystalize, getDefault } from ".";
+import { CascadePaths } from "./cascadePaths";
 import { ConstantRegistry } from "./constantRegistry";
 import {
   ConstantField,
@@ -193,6 +194,7 @@ const getBaseConstantClass = (field: FieldObject, modelType: ConstantType = "sca
     static readonly [FIELD_META]: FieldObject = field;
     static modelType: ConstantType = modelType;
     static text: TextFieldPaths = new TextFieldPaths();
+    static cascade: CascadePaths = new CascadePaths();
     static children: Set<ConstantModelRef> = new Set();
     static relations: Set<ConstantModelRef> = new Set();
     static enums: Set<EnumInstance> = new Set();
@@ -269,6 +271,7 @@ export interface ConstantStatics<
   relations: Set<ConstantModelRef>;
   enums: Set<EnumInstance>;
   text: TextFieldPaths;
+  cascade: CascadePaths;
   _OptionalKey: OptionalKey;
   _RelationKey: RelationKey;
   _PrimitiveKey: PrimitiveKey;
@@ -296,6 +299,7 @@ export interface DatabaseConstantStatics<Schema = any, FieldObj extends FieldObj
   relations: Set<ConstantModelRef>;
   enums: Set<EnumInstance>;
   text: TextFieldPaths;
+  cascade: CascadePaths;
   _DatabaseSchema: {
     [K in keyof Schema]: K extends keyof FieldObj
       ? FieldObj[K]["fieldType"] extends "hidden"
@@ -318,6 +322,7 @@ export type ConstantModelRef<
     relations: Set<ConstantModelRef>;
     enums: Set<EnumInstance>;
     text: TextFieldPaths;
+    cascade: CascadePaths;
   }
 >;
 
@@ -440,6 +445,7 @@ const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldO
     for (const relation of field.modelRef.relations) model.relations.add(relation);
   });
   model.text.collect(fieldMap);
+  model.cascade.collect(fieldMap);
   return model as unknown as ConstantCls<Model>;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.4.2-rc.1",
+  "version": "2.4.2-rc.2",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/di/diLifecycle.ts

@@ -457,7 +457,13 @@ export class DiLifecycle {
             if (serviceCls.type === "database") {
               const databaseModule = this.#database.get(serviceCls.refName);
               if (!databaseModule) throw new Error(`Database "${serviceCls.refName}" is not registered`);
-              ServiceResolver.resolveDatabaseService(databaseModule.constant, databaseModule.database, serviceCls);
+              ServiceResolver.resolveDatabaseService(
+                databaseModule.constant,
+                databaseModule.database,
+                serviceCls,
+
+                (refName) => this.getService(refName),
+              );
             }
             const service = new serviceCls();
             await InjectInfo.resolveInjection(service, serviceCls, this.registry, this.#env);

package/server/proxy/hostBasePathWebProxy.ts

@@ -1,12 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import { getEnv } from "akanjs/base";
+import { Logger, resolveSubRouteHosts } from "akanjs/common";
 import type { BaseBuildArtifact } from "../types";
 import { AkanResponse } from "./akanResponse";
 import type { WebProxy } from "./types";
 
 export class HostBasePathWebProxy implements WebProxy {
   static readonly refName = "HostBasePathWebProxy";
+  #logger = new Logger("HostBasePathWebProxy");
   #domainMap: Map<string, string> | null = null;
 
   use(request: Bun.BunRequest) {
@@ -49,7 +51,16 @@ export class HostBasePathWebProxy implements WebProxy {
 
   #getDomainMap(): Map<string, string> {
     if (this.#domainMap) return this.#domainMap;
-    const subRoutes = loadWebRouteMetadata();
+    const metadata = loadWebRouteMetadata();
+    const { subRoutes, ignoredBasePaths } = resolveSubRouteHosts({
+      subRoutes: metadata.subRoutes,
+      basePaths: metadata.basePaths,
+      env: process.env.AKAN_SUB_ROUTE_HOSTS,
+    });
+    if (ignoredBasePaths.length)
+      this.#logger.warn(
+        `AKAN_SUB_ROUTE_HOSTS names basePaths this build does not serve, ignoring: ${ignoredBasePaths.join(", ")}`,
+      );
     const map = new Map<string, string>();
     for (const [basePath, domains] of Object.entries(subRoutes)) {
       for (const domain of domains) map.set(normalizeHost(domain), basePath);
@@ -59,14 +70,14 @@ export class HostBasePathWebProxy implements WebProxy {
   }
 }
 
-function loadWebRouteMetadata() {
+function loadWebRouteMetadata(): Pick<BaseBuildArtifact, "subRoutes" | "basePaths"> {
   const artifactPath = path.join(resolveArtifactDir(), "base-artifact.json");
-  if (!fs.existsSync(artifactPath)) return { routes: [] };
+  if (!fs.existsSync(artifactPath)) return { subRoutes: {}, basePaths: [] };
   try {
     const parsed = JSON.parse(fs.readFileSync(artifactPath, "utf8")) as Partial<BaseBuildArtifact>;
-    return parsed.subRoutes ?? {};
+    return { subRoutes: parsed.subRoutes ?? {}, basePaths: parsed.basePaths ?? [] };
   } catch {
-    return { routes: [] };
+    return { subRoutes: {}, basePaths: [] };
   }
 }
 

package/server/resolver/service.resolver.ts

@@ -1,6 +1,6 @@
 import type { PromiseOrObject } from "akanjs/base";
 import { capitalize } from "akanjs/common";
-import type { ConstantModel, QueryOf } from "akanjs/constant";
+import { type ConstantModel, ConstantRegistry, type QueryOf } from "akanjs/constant";
 import {
   type CRUDEventType,
   type DatabaseModel,
@@ -17,7 +17,11 @@ import {
 import type { DatabaseService, ServiceCls } from "akanjs/service";
 
 export class ServiceResolver {
-  static #getDefaultDbServiceMethods(className: string) {
+  static #getDefaultDbServiceMethods(
+    className: string,
+    cascades: [string, string][],
+    getService: (refName: string) => DatabaseService,
+  ) {
     const dbServiceMethods = {
       async __get(this: DatabaseService, id: string) {
         return await this.__databaseModel.__get(id);
@@ -95,9 +99,18 @@ export class ServiceResolver {
         return this.__update(id, data);
       },
       async __remove(this: DatabaseService, id: string): Promise<Doc> {
+
+        const targets = cascades.map(([key, refName]) => [key, getService(refName)] as const);
         await this.__libsPreRemove(id);
         const doc = await this.__databaseModel.__remove(id);
-        return await this.__libsPostRemove(doc);
+        const removed = await this.__libsPostRemove(doc);
+        for (const [key, target] of targets) {
+          const value = (removed as Record<string, unknown>)[key];
+          const ids = (Array.isArray(value) ? value : [value]).filter((v): v is string => typeof v === "string");
+
+          for (const targetId of ids) await target.__remove(targetId);
+        }
+        return removed;
       },
       async [`remove${className}`](this: DatabaseService, id: string): Promise<Doc> {
         return this.__remove(id);
@@ -105,9 +118,18 @@ export class ServiceResolver {
     };
     return dbServiceMethods;
   }
-  static resolveDatabaseService(constant: ConstantModel, database: DatabaseModel, srvRef: ServiceCls): ServiceCls {
+  static resolveDatabaseService(
+    constant: ConstantModel,
+    database: DatabaseModel,
+    srvRef: ServiceCls,
+    getService: (refName: string) => DatabaseService,
+  ): ServiceCls {
     const className = capitalize(database.refName);
-    Object.assign(srvRef.prototype, ServiceResolver.#getDefaultDbServiceMethods(className));
+
+    const cascades = [...constant.full.cascade.remove].map(
+      ([key, modelRef]) => [key, ConstantRegistry.getRefName(modelRef)] as [string, string],
+    );
+    Object.assign(srvRef.prototype, ServiceResolver.#getDefaultDbServiceMethods(className, cascades, getService));
     const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
       const lastArg = args.at(-1);
       const hasQueryOption =

package/server/webRouter.ts

@@ -7,6 +7,7 @@ import {
   getBasePathFromPathname,
   Logger,
   parseAkanI18nEnv,
+  resolveSubRouteHosts,
 } from "akanjs/common";
 import { type AkanRequestStore, createRequestStore, parseCookieHeader } from "akanjs/fetch";
 import type { AkanMetricsReport } from "akanjs/service";
@@ -267,6 +268,7 @@ export class WebRouter {
   #logger = new Logger("WebRouter");
   #artifactDir = WebRouter.#resolveArtifactDir();
   #artifact: BaseBuildArtifact;
+  #subRoutes: Record<string, string[]>;
   #rsc: RscWorker;
   #hub: HmrWsHub | null = null;
   #prodMode = process.env.NODE_ENV === "production";
@@ -293,6 +295,16 @@ export class WebRouter {
   constructor({ artifact, cssBytesByUrl, rsc, seedIndex, upgradeHmrWs }: WebRouterOptions) {
     this.#logger.verbose(`[SSR] loaded ${Object.keys(cssBytesByUrl).length} CSS assets`);
     this.#artifact = artifact;
+    const { subRoutes, ignoredBasePaths } = resolveSubRouteHosts({
+      subRoutes: artifact.subRoutes,
+      basePaths: artifact.basePaths,
+      env: process.env.AKAN_SUB_ROUTE_HOSTS,
+    });
+    this.#subRoutes = subRoutes;
+    if (ignoredBasePaths.length)
+      this.#logger.warn(
+        `AKAN_SUB_ROUTE_HOSTS names basePaths this build does not serve, ignoring: ${ignoredBasePaths.join(", ")}`,
+      );
     this.#rsc = rsc;
     this.renderState = {
       buildId: 0,
@@ -424,8 +436,7 @@ export class WebRouter {
           const clientOrigin = WebRouter.#clientFacingOrigin(req);
           const target = reqUrl.searchParams.get("url");
           const rawTargetUrl = target ? new URL(target, clientOrigin) : reqUrl;
-          const requestBasePath =
-            req.headers.get("x-base-path") ?? WebRouter.#basePathForRequestHost(req, this.#artifact.subRoutes);
+          const requestBasePath = this.#requestBasePath(req);
           const normalizedTarget = normalizeRscTargetUrlForHostBasePath(rawTargetUrl, {
             basePath: requestBasePath,
             basePaths: this.#artifact.basePaths,
@@ -517,11 +528,7 @@ export class WebRouter {
           });
         }
 
-        const sitemapBasePath = getSitemapBasePath(
-          url.pathname,
-          this.#artifact.basePaths,
-          req.headers.get("x-base-path") ?? WebRouter.#basePathForRequestHost(req, this.#artifact.subRoutes),
-        );
+        const sitemapBasePath = getSitemapBasePath(url.pathname, this.#artifact.basePaths, this.#requestBasePath(req));
         if (sitemapBasePath !== undefined) {
           return new Response(
             createDefaultSitemapXml({
@@ -713,6 +720,17 @@ export class WebRouter {
     return getClientFacingOrigin(req);
   }
 
+  /**
+   * `x-base-path` is set by `HostBasePathWebProxy`, but it reaches here from the wire too, so it is checked against
+   * the basePaths this build serves — the same check `getBasePathFromPathname` already applies to it. An unknown
+   * value falls through to host matching instead of routing the request into a basePath that resolves to nothing.
+   */
+  #requestBasePath(req: Request): string | null {
+    const headerBasePath = req.headers.get("x-base-path");
+    if (headerBasePath && this.#artifact.basePaths.includes(headerBasePath)) return headerBasePath;
+    return WebRouter.#basePathForRequestHost(req, this.#subRoutes);
+  }
+
   static #basePathForRequestHost(req: Request, subRoutes: Record<string, string[]>): string | null {
     const host = (req.headers.get("x-forwarded-host") ?? req.headers.get("host") ?? "")
       .toLowerCase()
@@ -857,8 +875,7 @@ export class WebRouter {
       pathname,
       i18n: this.#artifact.i18n,
       basePaths: this.#artifact.basePaths,
-      headerBasePath:
-        req.headers.get("x-base-path") ?? WebRouter.#basePathForRequestHost(req, this.#artifact.subRoutes),
+      headerBasePath: this.#requestBasePath(req),
     });
   }
 
@@ -866,8 +883,7 @@ export class WebRouter {
     const basePath = getBasePathFromPathname(pathname, {
       basePaths: Object.keys(this.renderState.cssAssets),
       i18n: this.#artifact.i18n,
-      headerBasePath:
-        req.headers.get("x-base-path") ?? WebRouter.#basePathForRequestHost(req, this.#artifact.subRoutes),
+      headerBasePath: this.#requestBasePath(req),
     });
     return this.renderState.cssAssets[basePath ?? ""]?.cssUrl ?? null;
   }

package/types/common/index.d.ts

@@ -25,6 +25,6 @@ export { randomPicks } from "./randomPicks.d.ts";
 export { assertUniqueRoutePatterns, compareRouteSpecificity, isRouteSourceFile, isSpecialRouteLeaf, matchRoutePattern, normalizeRoutePattern, type ParsedRouteModuleKey, parseRouteModuleKey, type RouteModuleKind, routeSegmentToPatternPart, routeSegmentToTreePath, tryParseRouteModuleKey, type ValidatePageSourceFileOptions, type ValidateSubRoutePageKeyOptions, validatePageSourceFile, validateSubRoutePageKey, } from "./routeConvention.d.ts";
 export { sleep } from "./sleep.d.ts";
 export { splitVersion } from "./splitVersion.d.ts";
-export { getBasePathFromPathname, parseBasePaths } from "./subRoute.d.ts";
+export { getBasePathFromPathname, parseBasePaths, parseSubRouteHosts, resolveSubRouteHosts } from "./subRoute.d.ts";
 export type * from "./types.d.ts";
 export { type WebsocketAuthAckData, type WebsocketAuthRequest, websocketAuthContract, } from "./websocketAuth.d.ts";

package/types/common/subRoute.d.ts

@@ -1,5 +1,24 @@
 import type { AkanI18nConfig } from "./localeConfig.d.ts";
 export declare const parseBasePaths: (value: string | string[] | Set<string> | undefined | null) => string[];
+/**
+ * `"soft=a.com,b.com;office=c.com"` -> `{ soft: ["a.com", "b.com"], office: ["c.com"] }`. A deployment platform
+ * renders this value, so a malformed entry is skipped rather than thrown: one bad character must not CrashLoop
+ * every pod that received it.
+ */
+export declare const parseSubRouteHosts: (value: string | undefined | null) => Record<string, string[]>;
+/**
+ * Unions the env mapping onto the one baked into the build artifact, never replacing it — dropping the env is the
+ * rollback path. A basePath the build does not serve is reported back instead of honoured: the route tree is a
+ * build output, so accepting one would answer every request under it with a 404 and nothing to explain why.
+ */
+export declare const resolveSubRouteHosts: ({ subRoutes, basePaths, env, }: {
+    subRoutes: Record<string, string[]>;
+    basePaths: Iterable<string>;
+    env?: string | null;
+}) => {
+    subRoutes: Record<string, string[]>;
+    ignoredBasePaths: string[];
+};
 export declare const getBasePathFromPathname: (pathname: string, { basePaths, i18n, headerBasePath, }: {
     basePaths: Iterable<string>;
     i18n?: Pick<AkanI18nConfig, "locales" | "defaultLocale">;

package/types/constant/cascadePaths.d.ts

@@ -0,0 +1,11 @@
+import type { FieldObject } from "./fieldInfo.d.ts";
+import type { ConstantModelRef } from "./via.d.ts";
+/** What happens to the documents a relation field points at when the owner is removed. */
+export declare const cascadeActions: readonly ["remove"];
+export type CascadeAction = (typeof cascadeActions)[number];
+export declare class CascadePaths {
+    #private;
+    /** Field key → the model its ids point at. Resolved to a refName later: the target may not be registered yet. */
+    readonly remove: Map<string, ConstantModelRef>;
+    collect(fieldMap: FieldObject): this;
+}

package/types/constant/fieldInfo.d.ts

@@ -1,4 +1,5 @@
 import { type Any, CLIENT_VALUE, type Cls, type Dayjs, type EnumInstance, type Float, Int, type PrimitiveScalar, SERVER_VALUE, type SingleValue, type UnCls } from "akanjs/base";
+import type { CascadeAction } from "./cascadePaths.d.ts";
 import type { TextFieldRole } from "./textFieldPaths.d.ts";
 import type { BaseObject } from "./types.d.ts";
 import type { ConstantModelRef } from "./via.d.ts";
@@ -45,6 +46,7 @@ export interface ConstantFieldProps<FieldType extends ConstantFieldKind = Consta
     of?: MapValue;
     validate?: (value: FieldValue, model: any) => boolean;
     text?: TextFieldRole;
+    cascade?: CascadeAction;
     meta?: Metadata;
 }
 export declare const fieldPresets: readonly ["email", "password", "url"];
@@ -91,6 +93,7 @@ interface ConstantFieldBuildProps<FieldType extends ConstantFieldKind = any, Fie
     of?: MapValue;
     validate?: (value: FieldValue, model: any) => boolean;
     text?: TextFieldRole;
+    cascade?: CascadeAction;
     modelRef: ConstantModelRef;
     arrDepth: number;
     optArrDepth: number;
@@ -134,6 +137,7 @@ export declare class ConstantField<FieldType extends ConstantFieldKind = Constan
     readonly of?: MapValue;
     readonly validate?: (value: FieldValue, model: any) => boolean;
     readonly text?: TextFieldRole;
+    readonly cascade?: CascadeAction;
     readonly modelRef: ConstantModelRef;
     readonly arrDepth: number;
     readonly optArrDepth: number;

package/types/constant/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./cascadePaths.d.ts";
 export * from "./constantRegistry.d.ts";
 export * from "./crystalize.d.ts";
 export * from "./deserialize.d.ts";

package/types/constant/via.d.ts

@@ -1,4 +1,5 @@
 import { CLIENT_VALUE, type Cls, DEFAULT_VALUE, type EnumInstance, FIELD_META, type ObjectAssign, type ObjectAssignKeyOfObjects, PURIFIED_VALUE, SERVER_VALUE } from "akanjs/base";
+import { CascadePaths } from "./cascadePaths.d.ts";
 import { type ExtractFieldInfoObject, type FieldBuilder, type FieldInfoObject, type FieldInfoObjectToFieldObject, type FieldObject, type FieldResolver } from "./fieldInfo.d.ts";
 import { type PurifiedModel, type PurifyFunc } from "./purify.d.ts";
 import { TextFieldPaths } from "./textFieldPaths.d.ts";
@@ -34,6 +35,7 @@ export interface ConstantStatics<Schema = any, OwnSchema = Schema, OwnFieldObj e
     relations: Set<ConstantModelRef>;
     enums: Set<EnumInstance>;
     text: TextFieldPaths;
+    cascade: CascadePaths;
     _OptionalKey: OptionalKey;
     _RelationKey: RelationKey;
     _PrimitiveKey: PrimitiveKey;
@@ -60,6 +62,7 @@ export interface DatabaseConstantStatics<Schema = any, FieldObj extends FieldObj
     relations: Set<ConstantModelRef>;
     enums: Set<EnumInstance>;
     text: TextFieldPaths;
+    cascade: CascadePaths;
     _DatabaseSchema: {
         [K in keyof Schema]: K extends keyof FieldObj ? FieldObj[K]["fieldType"] extends "hidden" ? NonNullable<Schema[K]> : Schema[K] : Schema[K];
     };
@@ -71,6 +74,7 @@ export type ConstantModelRef<Schema = any, FieldObj extends FieldObject = FieldO
     relations: Set<ConstantModelRef>;
     enums: Set<EnumInstance>;
     text: TextFieldPaths;
+    cascade: CascadePaths;
 }>;
 export type DocumentConstantModelRef<Schema = any, FieldObj extends FieldObject = FieldObject, ModelType extends ConstantType = ConstantType, DatabaseSchema = DatabaseSchemaOf<Schema, never>> = Cls<Schema, {
     [FIELD_META]: FieldObj;

package/types/server/resolver/service.resolver.d.ts

@@ -1,7 +1,7 @@
-import type { ConstantModel } from "akanjs/constant";
+import { type ConstantModel } from "akanjs/constant";
 import { type DatabaseModel } from "akanjs/document";
-import type { ServiceCls } from "akanjs/service";
+import type { DatabaseService, ServiceCls } from "akanjs/service";
 export declare class ServiceResolver {
     #private;
-    static resolveDatabaseService(constant: ConstantModel, database: DatabaseModel, srvRef: ServiceCls): ServiceCls;
+    static resolveDatabaseService(constant: ConstantModel, database: DatabaseModel, srvRef: ServiceCls, getService: (refName: string) => DatabaseService): ServiceCls;
 }