akanjs 3.0.0-alpha.58 → 3.0.0-alpha.59

package/client/sharedContext.ts

@@ -1,3 +1,4 @@
+"use client";
 import { type Context, createContext } from "react";
 
 /**

package/client/translator.ts

@@ -1,4 +1,4 @@
-import { pathGet } from "akanjs/common";
+import { pathGetLoose } from "akanjs/common";
 
 export interface Dictionary {
   [key: string]: {
@@ -63,7 +63,7 @@ export class Translator {
   static translateByLocale(lang: string, key: string, param?: Record<string, string | number>): string {
     const dictionary = getTranslatorState().langDictionaryMap.get(lang);
     if (!dictionary) return key;
-    const msg = (pathGet(key, dictionary, ".", { t: key }) as { t: string }).t;
+    const msg = (pathGetLoose(key, dictionary, ".", { t: key }) as { t: string }).t;
     return param ? msg.replace(/{([^}]+)}/g, (_, key: string) => param[key] as string) : msg;
   }
 

package/common/index.ts

@@ -39,6 +39,7 @@ export {
 export { mergeVersion } from "./mergeVersion";
 export { objectify } from "./objectify";
 export { pathGet } from "./pathGet";
+export { pathGetLoose } from "./pathGetLoose";
 export { pathSet } from "./pathSet";
 export { randomPick } from "./randomPick";
 export { randomPicks } from "./randomPicks";

package/common/pathGetLoose.ts

@@ -0,0 +1,31 @@
+type Indexable = Record<string, unknown>;
+
+const isIndexable = (value: unknown): value is Indexable => Object(value) === value;
+
+/**
+ * Reads a dotted path whose segments may themselves contain the separator.
+ *
+ * Dictionary keys are built as `<refName>.<value>` and an enum value is a real-world identifier — `gpt-5.6-terra`,
+ * `v1.2` — so the key is not a clean dotted path and `pathGet` splits it into segments that were never nodes.
+ * The tree stores such a key literally, so resolution has to try joined prefixes too.
+ */
+export const pathGetLoose = (
+  path: string | readonly string[],
+  obj: unknown,
+  separator = ".",
+  fallback: unknown = null,
+): unknown => {
+  const walk = (node: unknown, rest: readonly string[]): unknown => {
+    if (!rest.length) return node;
+    if (!isIndexable(node)) return undefined;
+    
+    for (let take = 1; take <= rest.length; take += 1) {
+      const child = node[rest.slice(0, take).join(separator)];
+      if (child === undefined) continue;
+      const found = walk(child, rest.slice(take));
+      if (found !== undefined) return found;
+    }
+    return undefined;
+  };
+  return walk(obj, Array.isArray(path) ? [...path] : (path as string).split(separator)) ?? fallback;
+};

package/dictionary/DictionaryLookup.ts

@@ -1,4 +1,4 @@
-import { pathGet } from "akanjs/common";
+import { pathGetLoose } from "akanjs/common";
 import { DictionaryRegistry } from "./dictionaryRegistry";
 import type { DictionaryNode } from "./trans";
 
@@ -23,7 +23,7 @@ export class DictionaryLookup {
     const [refName, ...rest] = key.split(".");
     if (!refName) return undefined;
     const model = this.#models[refName];
-    const node = (rest.length ? pathGet(rest.join("."), model) : model) as { t?: unknown } | null;
+    const node = (rest.length ? pathGetLoose(rest, model) : model) as { t?: unknown } | null;
     const text = node?.t;
     return typeof text === "string" && text.length ? text : undefined;
   }

package/dictionary/trans.ts

@@ -1,5 +1,5 @@
 import type { GetStateObject, ObjectAssign, Prettify } from "akanjs/base";
-import { pathGet } from "akanjs/common";
+import { pathGetLoose } from "akanjs/common";
 
 import { DictionaryRegistry } from "./dictionaryRegistry";
 import type { DictModule } from "./locale";
@@ -177,7 +177,7 @@ export const makeTrans = <
     const msgKey = msgKeys.join(".");
     const langDict = rootDictionary[lang] ?? {};
     const model = langDict[modelName as string] ?? {};
-    const message = pathGet(msgKey as string, model, ".", { t: key }) as { t: string };
+    const message = pathGetLoose(msgKey as string, model, ".", { t: key }) as { t: string };
     return message.t;
   };
   const getDictionary = (lang: Language) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.58",
+  "version": "3.0.0-alpha.59",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/service/predefinedAdaptor/database.adaptor.ts

@@ -981,6 +981,7 @@ export class SqlDocumentStore {
   #insertStmt: AkanSqlStatement | null = null;
   #readStmtCache = new Map<string, AkanSqlStatement>();
   #docPrototype: object | null = null;
+  #immutableKeys: string[] | null = null;
 
   constructor(
     private readonly owner: DocumentDatabaseOwner,
@@ -1483,7 +1484,9 @@ export class SqlDocumentStore {
     originalData: DocumentRecord,
     { runSaveHooks = true, crudType = "update" }: WriteHookOptions = {},
   ) {
-    const doc = this.hydrate(this.prepareDocument({ ...data, id, updatedAt: dayjs() }), originalData);
+    const prepared = this.prepareDocument({ ...data, id, updatedAt: dayjs() });
+    this.#assertImmutableUnchanged(prepared, originalData);
+    const doc = this.hydrate(prepared, originalData);
     if (runSaveHooks) await this.runHooks("save", crudType, doc, "pre");
     await this.runHooks(crudType, crudType, doc, "pre");
     const row = this.toRow(doc);
@@ -1498,6 +1501,19 @@ export class SqlDocumentStore {
     return doc;
   }
 
+  #assertImmutableUnchanged(prepared: DocumentRecord, originalData: DocumentRecord) {
+    this.#immutableKeys ??= Object.entries(this.database.doc[FIELD_META] as unknown as FieldMap)
+      .filter(([, fieldMeta]) => fieldMeta.getProps().immutable)
+      .map(([key]) => key);
+    if (!this.#immutableKeys.length) return;
+    const changed = this.#immutableKeys.filter((key) => jsonStr(prepared[key]) !== jsonStr(originalData[key]));
+    if (!changed.length) return;
+    
+    throw new Error(
+      `Cannot modify immutable field${changed.length > 1 ? "s" : ""} on ${this.table} (${String(prepared.id)}): ${changed.join(", ")}`,
+    );
+  }
+
   private parseProjectedValue(value: unknown) {
     if (typeof value !== "string") return value;
     const trimmed = value.trim();

package/types/common/index.d.ts

@@ -21,6 +21,7 @@ export { isMcpDescribableArg, type McpExposureEndpoint, type McpExposureOption,
 export { mergeVersion } from "./mergeVersion.d.ts";
 export { objectify } from "./objectify.d.ts";
 export { pathGet } from "./pathGet.d.ts";
+export { pathGetLoose } from "./pathGetLoose.d.ts";
 export { pathSet } from "./pathSet.d.ts";
 export { randomPick } from "./randomPick.d.ts";
 export { randomPicks } from "./randomPicks.d.ts";

package/types/common/pathGetLoose.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads a dotted path whose segments may themselves contain the separator.
+ *
+ * Dictionary keys are built as `<refName>.<value>` and an enum value is a real-world identifier — `gpt-5.6-terra`,
+ * `v1.2` — so the key is not a clean dotted path and `pathGet` splits it into segments that were never nodes.
+ * The tree stores such a key literally, so resolution has to try joined prefixes too.
+ */
+export declare const pathGetLoose: (path: string | readonly string[], obj: unknown, separator?: string, fallback?: unknown) => unknown;

package/ui/Signal/Object.tsx

@@ -90,7 +90,7 @@ const ObjectDetail = ({ className, objRef }: ObjectDetailProps) => {
                       <ObjectType objRef={modelRef} arrDepth={arrDepth} nullable={nullable} />
                     ) : (
                       <span className={docPill("muted", "font-mono")}>
-                        {typeLabel(ConstantRegistry.getModelName(modelRef), arrDepth, nullable)}
+                        {typeLabel(isMap ? "Map" : ConstantRegistry.getModelName(modelRef), arrDepth, nullable)}
                       </span>
                     )}
                     {isMap ? (

package/ui/Signal/makeExample.ts

@@ -8,10 +8,15 @@ import {
   PrimitiveRegistry,
   type PrimitiveScalar,
 } from "akanjs/base";
-import { type ConstantCls, ConstantRegistry } from "akanjs/constant";
+import { type ConstantCls, type ConstantField, ConstantRegistry } from "akanjs/constant";
 
 import type { SerializedArg, SerializedEndpoint, SignalType } from "akanjs/signal";
 
+const getMapExample = (field: ConstantField, getValueExample: (modelRef: Cls) => unknown) => {
+  const [valueRef, valueArrDepth] = getNonArrayModel(field.of as Cls);
+  return { key: arraiedModel(getValueExample(valueRef as Cls), valueArrDepth) };
+};
+
 const getResponseExample = (ref: Cls | Cls[]) => {
   const [modelRef, arrDepth] = getNonArrayModel(ref);
   const isPrimitive = PrimitiveRegistry.has(modelRef);
@@ -21,6 +26,7 @@ const getResponseExample = (ref: Cls | Cls[]) => {
   Object.entries((modelRef as ConstantCls)[FIELD_META]).forEach(([key, field]) => {
     if (field.example) example[key] = field.example as unknown;
     else if (field.enum) example[key] = arraiedModel<string>(field.enum.values[0] as string, field.arrDepth);
+    else if (field.isMap) example[key] = getMapExample(field, getResponseExample);
     else example[key] = getResponseExample(field.modelRef);
   });
   const result = arraiedModel(example, arrDepth);
@@ -33,7 +39,8 @@ const getRequestExample = (modelRef: Cls) => {
   if (isPrimitive) return (modelRef as typeof PrimitiveScalar)[EXAMPLE_VALUE];
   else {
     Object.entries((modelRef as ConstantCls)[FIELD_META]).forEach(([key, field]) => {
-      if (!field.isScalar && field.isClass) example[key] = "ObjectID";
+      if (field.isMap) example[key] = getMapExample(field, getRequestExample);
+      else if (!field.isScalar && field.isClass) example[key] = "ObjectID";
       else
         example[key] = (
           (field.example ?? field.enum)