@apexkit/cli 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apexkit/cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "The official CLI and developer sync engine for ApexKit",
   "type": "module",
   "main": "./src/index.js",

package/src/index.js

@@ -141,7 +141,7 @@ const TRIGGER_DEFINITIONS = [
   { id: "graphql", name: "graphql (Custom Resolver)", desc: "Dynamic Query/Mutation field resolver for GraphQL schema." }
 ];
 
-// --- 4. WORKSPACE TYPES & CONFIG GENERATOR ---
+// --- 4. ACCURATE WORKSPACE TYPES & CONFIG GENERATOR ---
 async function generateWorkspaceFiles() {
   console.log("  ⏳ Fetching collection schemas from DB...");
   let collectionsData = [];
@@ -155,6 +155,34 @@ async function generateWorkspaceFiles() {
     console.warn(`  ⚠️ Could not connect to DB for schemas: ${err.message}`);
   }
 
+  // Pre-calculate lookup maps for collection IDs and Names
+  const colIdToName = new Map();
+  const colNameToId = new Map();
+  collectionsData.forEach((col) => {
+    colIdToName.set(String(col.id), col.name);
+    colNameToId.set(col.name, col.id);
+  });
+
+  // Calculate Reverse Relations: Target Collection Name -> Array of Reverse Link Definitions
+  const reverseRelationsMap = new Map();
+  collectionsData.forEach((originCol) => {
+    if (originCol.schema?.relations) {
+      for (const [relName, relDef] of Object.entries(originCol.schema.relations)) {
+        const rawTarget = relDef.target_collection;
+        const targetName = colIdToName.get(String(rawTarget)) || rawTarget;
+
+        if (!reverseRelationsMap.has(targetName)) {
+          reverseRelationsMap.set(targetName, []);
+        }
+        reverseRelationsMap.get(targetName).push({
+          originCollection: originCol.name,
+          relationFieldName: relName,
+          cardinality: relDef.relation_type, // 'many' or 'one'
+        });
+      }
+    }
+  });
+
   let collectionTypesStr = `export interface Collections {\n`;
   let collectionExpandsStr = `export interface CollectionExpands {\n`;
   const collectionNames = [];
@@ -165,6 +193,7 @@ async function generateWorkspaceFiles() {
     let expandsStr = "";
 
     if (col.schema) {
+      // 1. STANDARD FIELDS
       if (col.schema.fields) {
         for (const [name, def] of Object.entries(col.schema.fields)) {
           let tsType = "any";
@@ -183,6 +212,7 @@ async function generateWorkspaceFiles() {
               break;
             case "owner":
             case "relation":
+              // ✅ Foreign keys and owners are ALWAYS scalar IDs on the record itself
               tsType = "number | string";
               break;
             case "boolean":
@@ -206,21 +236,59 @@ async function generateWorkspaceFiles() {
           }
           const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
           fieldsStr += `    ${safeName}${def.required ? "" : "?"}: ${tsType};\n`;
+
+          // If it's an Owner field, it expands to the User Profile map
+          if (def.type === "owner") {
+            expandsStr += `    ${safeName}?: { id: number | string; email: string; role: string; metadata?: Record<string, any> };\n`;
+          }
         }
       }
 
+      // 2. FORWARD RELATIONS (Directly on this collection)
       if (col.schema.relations) {
         for (const [name, rel] of Object.entries(col.schema.relations)) {
-          const isMany = rel.relation_type === "many";
-          const tsType = isMany ? "(number | string)[]" : "number | string";
+          const rawTarget = rel.target_collection;
+          const targetColName = colIdToName.get(String(rawTarget)) || rawTarget;
           const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) ? name : `"${name}"`;
-          fieldsStr += `    ${safeName}${rel.required ? "" : "?"}: ${tsType};\n`;
 
-          const targetCol = rel.target_collection;
-          const expandType = `{ id: number | string; data: Collections["${targetCol}"]; created: string; updated: string; expand?: any }`;
-          expandsStr += `    ${safeName}?: ${isMany ? `Array<${expandType}>` : expandType};\n`;
+          // ✅ BULLETPROOF RULE 1:
+          // A record holding the foreign key field stores a SCALAR foreign key ID, NEVER an array.
+          fieldsStr += `    ${safeName}${rel.required ? "" : "?"}: number | string;\n`;
+
+          // ✅ BULLETPROOF RULE 2:
+          // Forward expansion from the foreign key field points to ONE target record.
+          // It is ALWAYS a Map/Object, NEVER an array!
+          const targetRecordType = `Collections["${targetColName}"]`;
+          const expandSingleType = `{ id: number | string; data: ${targetRecordType}; created: string; updated: string; expand?: any }`;
+
+          expandsStr += `    ${safeName}?: ${expandSingleType};\n`;
         }
       }
+
+      // 3. REVERSE RELATIONS (Parent expanding children)
+      const reverseLinks = reverseRelationsMap.get(col.name) || [];
+      const fieldCountByName = new Map();
+      reverseLinks.forEach((rev) => {
+        fieldCountByName.set(rev.originCollection, (fieldCountByName.get(rev.originCollection) || 0) + 1);
+      });
+
+      reverseLinks.forEach((rev) => {
+        const isDuplicate = (fieldCountByName.get(rev.originCollection) || 0) > 1;
+        const revKey = isDuplicate ? `${rev.originCollection}_via_${rev.relationFieldName}` : rev.originCollection;
+        const safeRevKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(revKey) ? revKey : `"${revKey}"`;
+
+        const originRecordType = `Collections["${rev.originCollection}"]`;
+        const childRecordType = `{ id: number | string; data: ${originRecordType}; created: string; updated: string; expand?: any }`;
+
+        // ✅ BULLETPROOF RULE 3:
+        // Only return an Array when reverse-expanded from parent AND cardinality is 'many'.
+        // If the reverse relation is unique ('one'), return a single Map/Object.
+        if (rev.cardinality === "one") {
+          expandsStr += `    ${safeRevKey}?: ${childRecordType};\n`;
+        } else {
+          expandsStr += `    ${safeRevKey}?: Array<${childRecordType}>;\n`;
+        }
+      });
     }
 
     collectionTypesStr += `  "${col.name}": {\n${fieldsStr}  };\n`;
@@ -460,10 +528,58 @@ declare global {
     base64EncodeBuffer(buffer: ArrayBuffer | Uint8Array): string;
     base64Decode(text: string): string;
     base64DecodeBuffer(text: string): ArrayBuffer;
+    textEncode(text: string): ArrayBuffer;
+    textDecode(data: ArrayBuffer | Uint8Array): string;
+    hexEncode(data: string | ArrayBuffer | Uint8Array): string;
+    hexDecode(hex: string): ArrayBuffer;
     sleep(ms: number): Promise<void>;
     randomHex(len?: number): string;
   };
 
+  /** Standard Web APIs */
+  const crypto: {
+    randomUUID(): string;
+    getRandomValues<T extends Int8Array | Int16Array | Int32Array | Uint8Array | Uint16Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array | DataView | null>(array: T): T;
+    subtle: {
+      digest(algorithm: string | any, data: ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
+      importKey(format: string, keyData: any, algo: any, extractable: boolean, usages: string[]): Promise<any>;
+      sign(algorithm: string | any, key: any, data: ArrayBuffer | Uint8Array): Promise<ArrayBuffer>;
+      verify(algorithm: string | any, key: any, signature: ArrayBuffer | Uint8Array, data: ArrayBuffer | Uint8Array): Promise<boolean>;
+    }
+  };
+
+  class Blob {
+    constructor(sources?: any[], options?: any);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    text(): Promise<string>;
+    readonly size: number;
+    readonly type: string;
+  }
+
+  class ReadableStream {
+    constructor(underlyingSource?: any);
+    getReader(): any;
+    cancel(): Promise<void>;
+    readonly locked: boolean;
+  }
+
+  const btoa: (data: string) => string;
+  const atob: (data: string) => string;
+
+  class TextEncoder {
+    constructor(encoding?: string);
+    encode(input?: string): Uint8Array;
+    encodeInto(source: string, destination: Uint8Array): { read: number; written: number };
+  }
+
+  class TextDecoder {
+    constructor(label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean });
+    decode(input?: ArrayBuffer | Uint8Array, options?: { stream?: boolean }): string;
+  }
+
+  function setTimeout(callback: Function, ms: number): string;
+  function clearTimeout(id: string): void;
+
   /** Environment & Configuration Secrets Accessor */
   const $env: {
     get(key: string): Promise<string>;
@@ -484,7 +600,7 @@ declare global {
 export {};
 `;
   fs.writeFileSync("apexkit.d.ts", types.trim());
-  console.log("  📄 Generated apexkit.d.ts with Engine & Collection Typings");
+  console.log("  📄 Generated apexkit.d.ts with Accurate Scaled & Relational Typings");
 
   const jsconfig = {
     compilerOptions: {
@@ -566,7 +682,7 @@ export default async function (context) {
 <head>
   <meta charset="UTF-8">
   <title>{{ title }}</title>
-  <link rel="stylesheet" href="/styles.css">
+  <script src="https://cdn.tailwindcss.com"></script>
   <script src="/static/js/htmx.js"></script>
   <script src="/static/js/alpine.js" defer></script>
 </head>
@@ -575,10 +691,10 @@ export default async function (context) {
     <h1 class="text-3xl font-bold text-indigo-400">{{ title }}</h1>
     
     <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
-      {% for item in items %}
+      {% for post in posts %}
       <div class="p-4 bg-slate-800 rounded-lg border border-slate-700 shadow">
-        <h2 class="text-xl font-semibold">{{ item.data.title | default(value="Item #" ~ item.id) }}</h2>
-        <p class="text-slate-400 text-sm mt-2">{{ item.created }}</p>
+        <h2 class="text-xl font-semibold">{{ post.data.title | default(value="Item #" ~ post.id) }}</h2>
+        <p class="text-slate-400 text-sm mt-2">{{ post.created }}</p>
       </div>
       {% endfor %}
     </div>