@zodic/shared 0.0.175 → 0.0.177

package/app/durable/ConceptNameDO.ts

@@ -1,69 +1,135 @@
-import { DurableObjectState } from '@cloudflare/workers-types';
+import { DurableObjectState } from "@cloudflare/workers-types";
+import { BackendBindings, ConceptProgress } from "../../types";
 
-export class ConceptNameDO extends DurableObject {
+export class ConceptNameDO {
   state: DurableObjectState;
   env: any;
-  names: { 'en-us': string[]; 'pt-br': string[] };
+  names: Record<string, { 'en-us': string[]; 'pt-br': string[] }>;
+  counts: Record<string, number>;
+  timestamps: Record<string, number[]>;
 
-  constructor(state: DurableObjectState, env: any) {
-    super(state, env); // ✅ Call super() for DurableObject
+  static TOTAL_NAMES = 1728; // Max names per concept
+
+  constructor(state: DurableObjectState, env: BackendBindings) {
     this.state = state;
     this.env = env;
-    this.names = { 'en-us': [], 'pt-br': [] };
+    this.names = {};
+    this.counts = {};
+    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 === '/names') {
-      await this.loadNames();
-      return new Response(JSON.stringify(this.names), {
+    if (method === 'GET' && url.pathname.endsWith('/names')) {
+      return new Response(JSON.stringify(await this.getNames(conceptSlug)), {
         headers: { 'Content-Type': 'application/json' },
       });
     }
 
-    if (method === 'POST' && url.pathname === '/add-name') {
-      try {
-        const { language, name } = (await request.json()) as {
-          language: 'en-us' | 'pt-br';
-          name: string;
-        };
+    if (method === 'GET' && url.pathname.endsWith('/progress')) {
+      return new Response(JSON.stringify(await this.calculateProgress(conceptSlug)), {
+        headers: { 'Content-Type': 'application/json' },
+      });
+    }
 
-        if (!['en-us', 'pt-br'].includes(language)) {
-          return new Response('Invalid language', { status: 400 });
-        }
+    if (method === 'POST' && url.pathname.endsWith('/add-name')) {
+      const { language, name } = (await request.json()) as {
+        language: 'en-us' | 'pt-br';
+        name: string;
+      };
 
-        await this.addName(language, name);
-        return new Response('OK', { status: 200 });
-      } catch (error) {
-        console.error('❌ Error processing request:', error);
-        return new Response('Bad Request', { status: 400 });
+      if (!['en-us', 'pt-br'].includes(language)) {
+        return new Response('Invalid language', { status: 400 });
       }
+
+      await this.addName(conceptSlug, language, name);
+      return new Response('OK', { status: 200 });
     }
 
     return new Response('Not Found', { status: 404 });
   }
 
-  async loadNames(): Promise<void> {
-    const stored = await this.state.storage.get<{
-      'en-us': string[];
-      'pt-br': string[];
-    }>('names');
+  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': [],
+        };
+    }
+    return this.names[conceptSlug];
+  }
 
-    if (stored) {
-      this.names = stored;
+  async getCount(conceptSlug: string): Promise<number> {
+    if (this.counts[conceptSlug] === undefined) {
+      this.counts = (await this.state.storage.get<Record<string, number>>('counts')) || {};
     }
+    return this.counts[conceptSlug] || 0;
   }
 
-  async addName(language: 'en-us' | 'pt-br', name: string): Promise<void> {
-    await this.loadNames(); // Ensure we have the latest names
+  async getTimestamps(conceptSlug: string): Promise<number[]> {
+    if (!this.timestamps[conceptSlug]) {
+      this.timestamps =
+        (await this.state.storage.get<Record<string, number[]>>('timestamps')) || {};
+    }
+    return this.timestamps[conceptSlug] || [];
+  }
 
-    if (!this.names[language].includes(name)) {
-      this.names[language].push(name);
+  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
 
-      // ✅ Ensure concurrent writes do not overwrite existing stored data
-      await this.state.storage.put('names', this.names);
+      this.incrementCount(conceptSlug);
+      this.recordTimestamp(conceptSlug);
     }
   }
-}
+
+  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 ratePerMinute = recentTimestamps.length;
+
+    const remainingNames = ConceptNameDO.TOTAL_NAMES - count;
+    const estimatedTimeMinutes = ratePerMinute > 0 ? remainingNames / ratePerMinute : null;
+
+    return {
+      concept: conceptSlug,
+      count,
+      total: ConceptNameDO.TOTAL_NAMES,
+      progress: ((count / ConceptNameDO.TOTAL_NAMES) * 100).toFixed(2) + '%',
+      ratePerMinute,
+      estimatedTimeMinutes: estimatedTimeMinutes ? Math.round(estimatedTimeMinutes) : 'N/A',
+    };
+  }
+}

package/app/services/ConceptService.ts

@@ -2,7 +2,7 @@ import { and, eq } from 'drizzle-orm';
 import { inject, injectable } from 'inversify';
 import 'reflect-metadata';
 import { v4 as uuidv4 } from 'uuid';
-import { ConceptNameDO, schema } from '../..';
+import { schema } from '../..';
 import { Concept, ControlNetConfig, Languages } from '../../types';
 import {
   KVConcept,
@@ -51,7 +51,9 @@ export class ConceptService {
         // ✅ Fetch the latest name list from Durable Object
         let allNamesEN: string[] = [];
         let allNamesPT: string[] = [];
-        const response = await stub.fetch('https://internal/names');
+        const response = await stub.fetch(
+          `https://internal/${conceptSlug}/names`
+        );
         if (response.ok) {
           const data = (await response.json()) as {
             'en-us': string[];
@@ -60,7 +62,7 @@ export class ConceptService {
           allNamesEN = data['en-us'] || [];
           allNamesPT = data['pt-br'] || [];
         } else {
-          console.log('!-- Error fetching names from Durable Object');
+          console.log(`!-- Error fetching names from DO for ${conceptSlug}`);
           console.log('!-- Response:', await response.text());
         }
 
@@ -71,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/add-name', {
+          await stub.fetch(`https://internal/${conceptSlug}/add-name`, {
             method: 'POST',
             body: JSON.stringify({ language: 'en-us', name: existingEN.name }),
             headers: { 'Content-Type': 'application/json' },
@@ -79,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/add-name', {
+          await stub.fetch(`https://internal/${conceptSlug}/add-name`, {
             method: 'POST',
             body: JSON.stringify({ language: 'pt-br', name: existingPT.name }),
             headers: { 'Content-Type': 'application/json' },
@@ -127,13 +129,13 @@ export class ConceptService {
         }
 
         // ✅ **Immediately update Durable Object with the new name**
-        await stub.fetch('https://internal/add-name', {
+        await stub.fetch(`https://internal/${conceptSlug}/add-name`, {
           method: 'POST',
           body: JSON.stringify({ language: 'en-us', name: nameEN }),
           headers: { 'Content-Type': 'application/json' },
         });
 
-        await stub.fetch('https://internal/add-name', {
+        await stub.fetch(`https://internal/${conceptSlug}/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.175",
+  "version": "0.0.177",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {

package/types/scopes/cloudflare.ts

@@ -26,7 +26,7 @@ export type CentralBindings = {
   KV_CONCEPT_FAILURES: KVNamespace;
   KV_CONCEPT_NAMES: KVNamespace;
   CONCEPT_GENERATION_QUEUE: Queue;
-  CONCEPT_NAMES_DO: DurableObjectNamespace<ConceptNameDO>;
+  CONCEPT_NAMES_DO: DurableObjectNamespace;
 
   PROMPT_IMAGE_DESCRIBER: string;
   PROMPT_GENERATE_ARCHETYPE_BASIC_INFO: string;

package/types/scopes/generic.ts

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