@zodic/shared 0.0.177 → 0.0.178

package/app/durable/ConceptNameDO.ts

@@ -1,45 +1,40 @@
-import { DurableObjectState } from "@cloudflare/workers-types";
-import { BackendBindings, ConceptProgress } from "../../types";
+import { DurableObjectState } from '@cloudflare/workers-types';
+import { BackendBindings, ConceptProgress } from '../../types';
 
 export class ConceptNameDO {
   state: DurableObjectState;
-  env: any;
-  names: Record<string, { 'en-us': string[]; 'pt-br': string[] }>;
-  counts: Record<string, number>;
-  timestamps: Record<string, number[]>;
+  env: BackendBindings;
+  names: { 'en-us': string[]; 'pt-br': string[] };
+  count: number;
+  timestamps: number[];
 
-  static TOTAL_NAMES = 1728; // Max names per concept
+  static TOTAL_NAMES = 1728; // Maximum total names to be generated
 
   constructor(state: DurableObjectState, env: BackendBindings) {
     this.state = state;
     this.env = env;
-    this.names = {};
-    this.counts = {};
-    this.timestamps = {};
+    this.names = { 'en-us': [], 'pt-br': [] };
+    this.count = 0;
+    this.timestamps = [];
   }
 
   async fetch(request: Request): Promise<Response> {
     const url = new URL(request.url);
     const method = request.method;
-    const conceptSlug = url.pathname.split('/')[2]; // Extract conceptSlug from URL
 
-    if (!conceptSlug) {
-      return new Response('Concept slug required', { status: 400 });
-    }
-
-    if (method === 'GET' && url.pathname.endsWith('/names')) {
-      return new Response(JSON.stringify(await this.getNames(conceptSlug)), {
+    if (method === 'GET' && url.pathname === '/names') {
+      return new Response(JSON.stringify(await this.getNames()), {
         headers: { 'Content-Type': 'application/json' },
       });
     }
 
-    if (method === 'GET' && url.pathname.endsWith('/progress')) {
-      return new Response(JSON.stringify(await this.calculateProgress(conceptSlug)), {
+    if (method === 'GET' && url.pathname === '/progress') {
+      return new Response(JSON.stringify(await this.getProgress()), {
         headers: { 'Content-Type': 'application/json' },
       });
     }
 
-    if (method === 'POST' && url.pathname.endsWith('/add-name')) {
+    if (method === 'POST' && url.pathname === '/add-name') {
       const { language, name } = (await request.json()) as {
         language: 'en-us' | 'pt-br';
         name: string;
@@ -49,87 +44,76 @@ export class ConceptNameDO {
         return new Response('Invalid language', { status: 400 });
       }
 
-      await this.addName(conceptSlug, language, name);
+      await this.addName(language, name);
       return new Response('OK', { status: 200 });
     }
 
     return new Response('Not Found', { status: 404 });
   }
 
-  async getNames(conceptSlug: string): Promise<{ 'en-us': string[]; 'pt-br': string[] }> {
-    if (!this.names[conceptSlug]) {
-      this.names[conceptSlug] =
-        (await this.state.storage.get<{ 'en-us': string[]; 'pt-br': string[] }>(`names:${conceptSlug}`)) || {
-          'en-us': [],
-          'pt-br': [],
-        };
+  async getNames(): Promise<{ 'en-us': string[]; 'pt-br': string[] }> {
+    if (!this.names['en-us'].length && !this.names['pt-br'].length) {
+      this.names = (await this.state.storage.get('names')) || {
+        'en-us': [],
+        'pt-br': [],
+      };
     }
-    return this.names[conceptSlug];
+    return this.names;
   }
 
-  async getCount(conceptSlug: string): Promise<number> {
-    if (this.counts[conceptSlug] === undefined) {
-      this.counts = (await this.state.storage.get<Record<string, number>>('counts')) || {};
+  async getProgress(): Promise<ConceptProgress> {
+    if (this.count === 0) {
+      this.count = (await this.state.storage.get<number>('count')) || 0;
     }
-    return this.counts[conceptSlug] || 0;
-  }
-
-  async getTimestamps(conceptSlug: string): Promise<number[]> {
-    if (!this.timestamps[conceptSlug]) {
+    if (this.timestamps.length === 0) {
       this.timestamps =
-        (await this.state.storage.get<Record<string, number[]>>('timestamps')) || {};
-    }
-    return this.timestamps[conceptSlug] || [];
-  }
-
-  async addName(conceptSlug: string, language: 'en-us' | 'pt-br', name: string): Promise<void> {
-    const names = await this.getNames(conceptSlug);
-    if (!names[language].includes(name)) {
-      names[language].push(name);
-      this.state.storage.put(`names:${conceptSlug}`, names); // ✅ No need to await
-
-      this.incrementCount(conceptSlug);
-      this.recordTimestamp(conceptSlug);
+        (await this.state.storage.get<number[]>('timestamps')) || [];
     }
-  }
-
-  async incrementCount(conceptSlug: string): Promise<void> {
-    const count = (await this.getCount(conceptSlug)) + 1;
-    this.counts[conceptSlug] = count;
-    this.state.storage.put('counts', this.counts); // ✅ No need to await
-  }
-
-  async recordTimestamp(conceptSlug: string): Promise<void> {
-    const now = Date.now();
-    const timestamps = await this.getTimestamps(conceptSlug);
 
-    // Keep only last 60 minutes
-    const filteredTimestamps = timestamps.filter((ts) => now - ts < 60 * 60 * 1000);
-    filteredTimestamps.push(now);
-
-    this.timestamps[conceptSlug] = filteredTimestamps;
-    this.state.storage.put('timestamps', this.timestamps); // ✅ No need to await
-  }
-
-  async calculateProgress(conceptSlug: string): Promise<ConceptProgress> {
     const now = Date.now();
     const oneMinuteAgo = now - 60 * 1000;
 
-    const count = await this.getCount(conceptSlug);
-    const timestamps = await this.getTimestamps(conceptSlug);
-    const recentTimestamps = timestamps.filter((ts) => ts >= oneMinuteAgo);
+    const recentTimestamps = this.timestamps.filter((ts) => ts >= oneMinuteAgo);
     const ratePerMinute = recentTimestamps.length;
 
-    const remainingNames = ConceptNameDO.TOTAL_NAMES - count;
-    const estimatedTimeMinutes = ratePerMinute > 0 ? remainingNames / ratePerMinute : null;
+    const remainingNames = ConceptNameDO.TOTAL_NAMES - this.count;
+    const estimatedTimeMinutes =
+      ratePerMinute > 0 ? Math.round(remainingNames / ratePerMinute) : 'N/A';
 
     return {
-      concept: conceptSlug,
-      count,
+      count: this.count,
       total: ConceptNameDO.TOTAL_NAMES,
-      progress: ((count / ConceptNameDO.TOTAL_NAMES) * 100).toFixed(2) + '%',
+      progress:
+        ((this.count / ConceptNameDO.TOTAL_NAMES) * 100).toFixed(2) + '%',
       ratePerMinute,
-      estimatedTimeMinutes: estimatedTimeMinutes ? Math.round(estimatedTimeMinutes) : 'N/A',
+      estimatedTimeMinutes,
     };
   }
-}
+
+  async addName(language: 'en-us' | 'pt-br', name: string): Promise<void> {
+    await this.getNames(); // Ensure latest state
+
+    if (!this.names[language].includes(name)) {
+      this.names[language].push(name);
+      this.count++;
+      this.recordTimestamp();
+
+      // ✅ **Batch storage writes** instead of multiple separate `put()` calls
+      await this.state.storage.put({
+        names: this.names,
+        count: this.count,
+        timestamps: this.timestamps,
+      });
+    }
+  }
+
+  recordTimestamp(): void {
+    const now = Date.now();
+
+    // Keep only the last 60 timestamps
+    if (this.timestamps.length >= 60) {
+      this.timestamps.splice(0, this.timestamps.length - 59);
+    }
+    this.timestamps.push(now);
+  }
+}

package/app/services/ConceptService.ts

@@ -52,7 +52,7 @@ export class ConceptService {
         let allNamesEN: string[] = [];
         let allNamesPT: string[] = [];
         const response = await stub.fetch(
-          `https://internal/${conceptSlug}/names`
+          `https://internal/names`
         );
         if (response.ok) {
           const data = (await response.json()) as {
@@ -73,7 +73,7 @@ export class ConceptService {
         // 🔥 If names already exist in KV but not in DO, add them
         if (existingEN.name && !allNamesEN.includes(existingEN.name)) {
           console.log(`⚡ Backfilling existing name to DO: ${existingEN.name}`);
-          await stub.fetch(`https://internal/${conceptSlug}/add-name`, {
+          await stub.fetch(`https://internal/add-name`, {
             method: 'POST',
             body: JSON.stringify({ language: 'en-us', name: existingEN.name }),
             headers: { 'Content-Type': 'application/json' },
@@ -81,7 +81,7 @@ export class ConceptService {
         }
         if (existingPT.name && !allNamesPT.includes(existingPT.name)) {
           console.log(`⚡ Backfilling existing name to DO: ${existingPT.name}`);
-          await stub.fetch(`https://internal/${conceptSlug}/add-name`, {
+          await stub.fetch(`https://internal/add-name`, {
             method: 'POST',
             body: JSON.stringify({ language: 'pt-br', name: existingPT.name }),
             headers: { 'Content-Type': 'application/json' },
@@ -129,13 +129,13 @@ export class ConceptService {
         }
 
         // ✅ **Immediately update Durable Object with the new name**
-        await stub.fetch(`https://internal/${conceptSlug}/add-name`, {
+        await stub.fetch(`https://internal/add-name`, {
           method: 'POST',
           body: JSON.stringify({ language: 'en-us', name: nameEN }),
           headers: { 'Content-Type': 'application/json' },
         });
 
-        await stub.fetch(`https://internal/${conceptSlug}/add-name`, {
+        await stub.fetch(`https://internal/add-name`, {
           method: 'POST',
           body: JSON.stringify({ language: 'pt-br', name: namePT }),
           headers: { 'Content-Type': 'application/json' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.177",
+  "version": "0.0.178",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {

package/types/scopes/generic.ts

@@ -400,10 +400,9 @@ export type AstroKVData = {
 };
 
 export type ConceptProgress = {
-  concept: string;
   count: number;
   total: number;
   progress: string; // Percentage as string (e.g., "75.32%")
   ratePerMinute: number;
   estimatedTimeMinutes: number | 'N/A';
-};
+};