@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/app/utils/{import_workflow.js → import_workflow.ts}

@@ -3,14 +3,21 @@
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json";
 
 // Local imports
+import { type NewDataItem, useDataStore } from "@ogw_front/stores/data";
 import { useBackStore } from "@ogw_front/stores/back";
-import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useTreeviewStore } from "@ogw_front/stores/treeview";
 
-async function importItem(item) {
+interface FileToImport {
+  readonly filename: string;
+  readonly geode_object_type: string;
+}
+
+// NewDataItem has mutable array fields (mesh_components, collection_components), so it can't
+// Satisfy prefer-readonly-parameter-types deeply; left unfixed (same pattern as app/plugins/auto_store_register.ts).
+async function importItem(item: NewDataItem): Promise<string> {
   const dataStore = useDataStore();
   const dataStyleStore = useDataStyleStore();
   const hybridViewerStore = useHybridViewerStore();
@@ -22,19 +29,19 @@ async function importItem(item) {
   const addDataTask = dataStore.addItem(item);
   const registerTask = addDataTask.then(async () => {
     if (!(await dataStore.isItemViewable(item))) {
-      return;
+      return undefined;
     }
-    return dataStore.registerObject(item.id, item.name);
+    return dataStore.registerObject(item.id, item.name ?? item.id);
   });
   const addDataComponentsTask =
     item.viewer_type === "model" ? dataStore.addComponents(item) : Promise.resolve();
   const addDataRelationsTask =
     item.viewer_type === "model" ? dataStore.addComponentRelations(item) : Promise.resolve();
-  treeviewStore.addItem(item.geode_object_type, item.name, item.id, item.viewer_type);
+  treeviewStore.addItem(item.geode_object_type, item.name ?? item.id, item.id, item.viewer_type);
   const addDataStyleTask = dataStyleStore.addDataStyle(item.id, item.geode_object_type);
   const addViewerTask = addDataTask.then(async () => {
     if (!(await dataStore.isItemViewable(item))) {
-      return;
+      return undefined;
     }
     return hybridViewerStore.addItem(item.id);
   });
@@ -56,7 +63,7 @@ async function importItem(item) {
   ]);
   return item.id;
 }
-async function importFile(filename, geode_object_type) {
+async function importFile(filename: string, geode_object_type: string): Promise<string> {
   const backStore = useBackStore();
   const schema = back_schemas.opengeodeweb_back.save_viewable_file;
   const params = {
@@ -67,54 +74,64 @@ async function importFile(filename, geode_object_type) {
     schema,
     params,
   });
-  return importItem(response);
+  // oxlint-disable-next-line no-unsafe-type-assertion -- this is the trusted API boundary; the back-end response shape matches NewDataItem.
+  return importItem(response as NewDataItem);
 }
 
-async function importWorkflow(files) {
+async function importWorkflow(files: readonly FileToImport[]): Promise<string[]> {
   const chunk_size = 5;
-  const chunks = [];
+  const chunks: FileToImport[][] = [];
   for (let i = 0; i < files.length; i += chunk_size) {
     chunks.push(files.slice(i, i + chunk_size));
   }
 
-  const results = [];
-  async function processChunk(chunkIndex) {
+  const results: string[] = [];
+  async function processChunk(chunkIndex: number): Promise<void> {
     if (chunkIndex >= chunks.length) {
       return;
     }
-    const chunk = chunks[chunkIndex];
+    const chunk = chunks[chunkIndex] ?? [];
     const chunk_results = await Promise.all(
-      chunk.map(({ filename, geode_object_type }) => importFile(filename, geode_object_type)),
+      chunk.map(async ({ filename, geode_object_type }) => {
+        const id = await importFile(filename, geode_object_type);
+        return id;
+      }),
     );
     results.push(...chunk_results);
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
   const hybridViewerStore = useHybridViewerStore();
-  hybridViewerStore.remoteRender();
+  await hybridViewerStore.remoteRender();
   return results;
 }
 
-async function importWorkflowFromSnapshot(items) {
+// NewDataItem has mutable array fields (mesh_components, collection_components), so a readonly array of it can't satisfy prefer-readonly-parameter-types deeply; left unfixed (same pattern as app/plugins/auto_store_register.ts).
+async function importWorkflowFromSnapshot(items: readonly NewDataItem[]): Promise<string[]> {
   console.log("[importWorkflowFromSnapshot] start", { count: items?.length });
   const hybridViewerStore = useHybridViewerStore();
   const chunk_size = 5;
-  const chunks = [];
+  const chunks: NewDataItem[][] = [];
   for (let i = 0; i < items.length; i += chunk_size) {
     chunks.push(items.slice(i, i + chunk_size));
   }
-  const ids = [];
-  async function processChunk(chunkIndex) {
+  const ids: string[] = [];
+  async function processChunk(chunkIndex: number): Promise<void> {
     if (chunkIndex >= chunks.length) {
       return;
     }
-    const chunk = chunks[chunkIndex];
-    const chunk_ids = await Promise.all(chunk.map((item) => importItem(item)));
+    const chunk = chunks[chunkIndex] ?? [];
+    const chunk_ids = await Promise.all(
+      chunk.map(async (item) => {
+        const id = await importItem(item);
+        return id;
+      }),
+    );
     ids.push(...chunk_ids);
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
-  hybridViewerStore.remoteRender();
+  await hybridViewerStore.remoteRender();
   console.log("[importWorkflowFromSnapshot] done", {
     ids,
   });

package/app/utils/{log.js → log.ts}

@@ -1,10 +1,20 @@
-function startRequestLog(microservice, schema) {
+import type { JsonRpcSchema } from "@ogw_shared/utils/types.js";
+
+interface Loggable {
+  $id: string;
+}
+
+function startRequestLog(microservice: Loggable, schema: JsonRpcSchema): Date {
   console.log(`[${microservice.$id}] Request:`, schema.$id);
   const requestStartingTime = new Date(Date.now());
   return requestStartingTime;
 }
 
-function endRequestLog(microservice, schema, requestStartingTime) {
+function endRequestLog(
+  microservice: Loggable,
+  schema: JsonRpcSchema,
+  requestStartingTime: Date,
+): void {
   const requestEndingTime = new Date(Date.now());
   console.log(
     `[${microservice.$id}] Request completed:`,

package/app/utils/{name_cleaner.js → name_cleaner.ts}

@@ -3,12 +3,12 @@ const DEFAULT_SLICE_START = 8;
 const DEFAULT_SLICE_END_OFFSET = 8;
 
 function formatListId(
-  id,
-  maxLength = DEFAULT_MAX_LENGTH,
-  sliceStart = DEFAULT_SLICE_START,
-  sliceEndOffset = DEFAULT_SLICE_END_OFFSET,
-) {
-  if (!id) {
+  id: string | undefined | null,
+  maxLength: number = DEFAULT_MAX_LENGTH,
+  sliceStart: number = DEFAULT_SLICE_START,
+  sliceEndOffset: number = DEFAULT_SLICE_END_OFFSET,
+): string {
+  if (id === undefined || id === null || id === "") {
     return "";
   }
   if (id.length <= maxLength) {

package/app/utils/status.ts

@@ -0,0 +1,19 @@
+interface StatusValues {
+  NOT_CREATED: string;
+  CREATING: string;
+  CREATED: string;
+  NOT_CONNECTED: string;
+  CONNECTING: string;
+  CONNECTED: string;
+}
+
+const Status: StatusValues = {
+  NOT_CREATED: "NOT_CREATED",
+  CREATING: "CREATING",
+  CREATED: "CREATED",
+  NOT_CONNECTED: "NOT_CONNECTED",
+  CONNECTING: "CONNECTING",
+  CONNECTED: "CONNECTED",
+};
+
+export { Status };

package/app/utils/{stores.js → stores.ts}

@@ -1,24 +1,24 @@
 import { appMode } from "@ogw_shared/app_mode";
 import { useInfraStore } from "@ogw_front/stores/infra";
 
-function isCloudMode() {
+function isCloudMode(): boolean {
   const infraStore = useInfraStore();
   return infraStore.app_mode === appMode.CLOUD;
 }
 
-function getRestApiProtocol() {
+function getRestApiProtocol(): string {
   const protocol = isCloudMode() ? "https" : "http";
   return protocol;
 }
-function getRestApiPort(defaultLocalPort) {
+function getRestApiPort(defaultLocalPort: string): string {
   const port = isCloudMode() ? "443" : defaultLocalPort;
   return port;
 }
-function getWebsocketApiProtocol() {
+function getWebsocketApiProtocol(): string {
   const protocol = isCloudMode() ? "wss" : "ws";
   return protocol;
 }
-function getWebsocketApiPort(defaultLocalPort) {
+function getWebsocketApiPort(defaultLocalPort: string): string {
   const port = isCloudMode() ? "443" : defaultLocalPort;
   return port;
 }

package/app/utils/{string.js → string.ts}

@@ -11,12 +11,12 @@ const DEFAULT_END_CHARS = 6;
  * @returns {string} The truncated string.
  */
 export function middleTruncate(
-  text,
-  maxLength = DEFAULT_MAX_LENGTH,
-  startChars = DEFAULT_START_CHARS,
-  endChars = DEFAULT_END_CHARS,
-) {
-  if (!text || text.length <= maxLength) {
+  text: string | undefined | null,
+  maxLength: number = DEFAULT_MAX_LENGTH,
+  startChars: number = DEFAULT_START_CHARS,
+  endChars: number = DEFAULT_END_CHARS,
+): string | undefined | null {
+  if (text === undefined || text === null || text.length <= maxLength) {
     return text;
   }
 

package/app/utils/{treeview.js → treeview.ts}

@@ -1,4 +1,7 @@
-function compareSelections(current, previous) {
+function compareSelections<Item>(
+  current: readonly Item[],
+  previous: readonly Item[],
+): { added: Item[]; removed: Item[] } {
   const added = current.filter((item) => !previous.includes(item));
   const removed = previous.filter((item) => !current.includes(item));
   return { added, removed };

package/internal/database/{base_database.js → base_database.ts}

@@ -8,7 +8,7 @@ import { modelComponentsRelationTable } from "./tables/model_components_relation
 import { modelComponentsTable } from "./tables/model_components";
 
 export class BaseDatabase extends Dexie {
-  static get initialStores() {
+  public static get initialStores(): Record<string, string> {
     return {
       [dataTable.name]: dataTable.schema,
       [modelComponentsTable.name]: modelComponentsTable.schema,
@@ -21,7 +21,11 @@ export class BaseDatabase extends Dexie {
     };
   }
 
-  clear() {
-    return Promise.all(this.tables.map((table) => table.clear()));
+  public async clear(): Promise<void> {
+    await Promise.all(
+      this.tables.map(async (table) => {
+        await table.clear();
+      }),
+    );
   }
 }

package/internal/database/database.ts

@@ -0,0 +1,102 @@
+import { Dexie, type Table } from "dexie";
+import { BaseDatabase } from "./base_database";
+import { ExtendedDatabase } from "./extended_database";
+
+interface DatabaseContainer {
+  instance: Dexie | undefined;
+}
+
+const databaseContainer: DatabaseContainer = { instance: undefined };
+
+class Database extends BaseDatabase {
+  public constructor() {
+    super("Database");
+
+    this.version(3).stores(BaseDatabase.initialStores);
+  }
+
+  public static async addTable(tableName: string, schemaDefinition: string): Promise<void> {
+    await this.addTables({ [tableName]: schemaDefinition });
+  }
+
+  public static async addTables(newTables: Record<string, string>): Promise<void> {
+    let currentVersion = 1;
+    let currentStores: Record<string, string> = { ...BaseDatabase.initialStores };
+
+    if (await Dexie.exists("Database")) {
+      const tempDb = new Dexie("Database");
+      await tempDb.open();
+
+      currentVersion = tempDb.verno;
+      currentStores = { ...BaseDatabase.initialStores };
+
+      for (const table of tempDb.tables) {
+        const keyPath = table.schema.primKey.src;
+        const indexes = table.schema.indexes.map((index) => index.src);
+        const parts = keyPath ? [keyPath, ...indexes] : indexes;
+        currentStores[table.name] = parts.join(",");
+      }
+
+      tempDb.close();
+    }
+
+    const allExisting = Object.keys(newTables).every(
+      (tableName) => currentStores[tableName] !== undefined,
+    );
+
+    // Set at module load time below; always defined by the time addTable/addTables runs.
+    databaseContainer.instance?.close();
+
+    if (allExisting) {
+      const existingDb = new Dexie("Database");
+      for (let version = 1; version <= currentVersion; version += 1) {
+        if (version === 1) {
+          existingDb.version(1).stores(BaseDatabase.initialStores);
+        } else {
+          existingDb.version(version).stores(currentStores);
+        }
+      }
+      await existingDb.open();
+      databaseContainer.instance = existingDb;
+    } else {
+      const newDb = new ExtendedDatabase(currentVersion, currentStores, newTables);
+      await newDb.open();
+      databaseContainer.instance = newDb;
+    }
+  }
+}
+
+// oxlint-disable-next-line no-top-level-await
+await Dexie.delete("Database");
+const initialDatabase = new Database();
+databaseContainer.instance = initialDatabase;
+// oxlint-disable-next-line no-top-level-await
+await initialDatabase.clear();
+
+// The set of tables is assembled dynamically at runtime (Database.addTable/addTables add stores on the fly), so fully modelling this with Dexie's row generics isn't worth it here: the proxy target is typed loosely as "any table name maps to a Dexie Table of loosely-typed rows".
+type DatabaseTables = Record<string, Table<Record<string, unknown>, string>>;
+
+const database = new Proxy<DatabaseTables>(
+  {},
+  {
+    get(_target, prop: string | symbol): unknown {
+      // The instance is a Dexie subclass whose tables are only known dynamically at runtime.
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      const instance = databaseContainer.instance as unknown as Record<string | symbol, unknown>;
+      const value = instance[prop];
+      if (typeof value === "function") {
+        // oxlint-disable-next-line no-unsafe-return
+        return value.bind(databaseContainer.instance);
+      }
+      return value;
+    },
+  },
+);
+
+// The proxy only knows the loose DatabaseTables shape; callers cast to the row type they know a given table holds.
+function getTable<TRow>(tableName: string): Table<TRow, string> {
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  return database[tableName] as unknown as Table<TRow, string>;
+}
+
+export { Database, database, getTable };

package/internal/database/{extended_database.js → extended_database.ts}

@@ -1,7 +1,11 @@
 import { BaseDatabase } from "./base_database";
 
 export class ExtendedDatabase extends BaseDatabase {
-  constructor(currentVersion, currentStores, newTables) {
+  public constructor(
+    currentVersion: number,
+    currentStores: Record<string, string>,
+    newTables: Record<string, string>,
+  ) {
     super("Database");
 
     for (let version = 1; version <= currentVersion; version += 1) {

package/internal/database/tables/camera_positions.ts

@@ -0,0 +1,6 @@
+import type { TableDefinition } from "./table_definition";
+
+export const cameraPositionsTable: TableDefinition = {
+  name: "camera_positions",
+  schema: "++id, name",
+};

package/internal/database/tables/{data.js → data.ts}

@@ -1,4 +1,6 @@
-export const dataTable = {
+import type { TableDefinition } from "./table_definition";
+
+export const dataTable: TableDefinition = {
   name: "data",
   schema: "id, name, viewer_type, geode_object_type, visible, created_at, binary_light_viewable",
 };

package/internal/database/tables/data_style.ts

@@ -0,0 +1,6 @@
+import type { TableDefinition } from "./table_definition";
+
+export const dataStyleTable: TableDefinition = {
+  name: "data_style",
+  schema: "id",
+};

package/internal/database/tables/model_component_datastyle.ts

@@ -0,0 +1,6 @@
+import type { TableDefinition } from "./table_definition";
+
+export const modelComponentDataStyleTable: TableDefinition = {
+  name: "model_component_datastyle",
+  schema: "[id_model+id_component], id_model",
+};

package/internal/database/tables/model_component_type_datastyle.ts

@@ -0,0 +1,6 @@
+import type { TableDefinition } from "./table_definition";
+
+export const modelComponentTypeDataStyleTable: TableDefinition = {
+  name: "model_component_type_datastyle",
+  schema: "[id_model+type], id_model",
+};

package/internal/database/tables/model_components.ts

@@ -0,0 +1,6 @@
+import type { TableDefinition } from "./table_definition";
+
+export const modelComponentsTable: TableDefinition = {
+  name: "model_components",
+  schema: "[id+geode_id], id, [id+type], viewer_id, name, is_active",
+};

package/internal/database/tables/model_components_relation.ts

@@ -0,0 +1,6 @@
+import type { TableDefinition } from "./table_definition";
+
+export const modelComponentsRelationTable: TableDefinition = {
+  name: "model_components_relation",
+  schema: "[id+parent+child], id, type",
+};

package/internal/database/tables/table_definition.ts

@@ -0,0 +1,5 @@
+// Shared shape for the static Dexie table descriptors below: each table module exports its store name and Dexie schema string (see Dexie's `.stores()` API).
+export interface TableDefinition {
+  name: string;
+  schema: string;
+}