@njdamstra/appwrite-utils-cli 1.11.0 → 1.11.2

package/dist/cli/commands/migrateCommands.js

@@ -11,7 +11,7 @@ export const migrateCommands = {
                 message: "String attribute migration:",
                 choices: [
                     {
-                        name: "Analyze — scan local configs, generate migration plan (YAML)",
+                        name: "Analyze — scan Appwrite server, generate migration plan (YAML)",
                         value: "analyze",
                     },
                     {
@@ -33,18 +33,33 @@ export const migrateCommands = {
     },
     async analyzePhase(cli) {
         const controller = cli.controller;
-        if (!controller?.config) {
-            MessageFormatter.error("No configuration loaded. Make sure you have a valid .appwrite config.", undefined, { prefix: "Analyze" });
+        if (!controller?.adapter) {
+            MessageFormatter.error("No database adapter available. Ensure a server connection is established.", undefined, { prefix: "Analyze" });
             return;
         }
-        const config = controller.config;
-        const collections = [
-            ...(config.collections || []),
-            ...(config.tables || []),
-        ];
-        if (collections.length === 0) {
-            MessageFormatter.warning("No collections/tables found in local config. Nothing to analyze.", { prefix: "Analyze" });
-            return;
+        // Prompt for database selection
+        const allDatabases = controller.config.databases || [];
+        let databaseIds;
+        if (allDatabases.length > 1) {
+            const { selectedDbs } = await inquirer.prompt([
+                {
+                    type: "checkbox",
+                    name: "selectedDbs",
+                    message: "Select databases to include in the analysis:",
+                    choices: allDatabases.map((db) => ({
+                        name: `${db.name} (${db.$id})`,
+                        value: db.$id,
+                        checked: true,
+                    })),
+                },
+            ]);
+            if (selectedDbs.length === 0) {
+                MessageFormatter.warning("No databases selected. Aborting.", { prefix: "Analyze" });
+                return;
+            }
+            if (selectedDbs.length < allDatabases.length) {
+                databaseIds = selectedDbs;
+            }
         }
         // Prompt for output path
         const { outputPath } = await inquirer.prompt([
@@ -55,9 +70,9 @@ export const migrateCommands = {
                 default: path.join(process.cwd(), "migrate-strings-plan.yaml"),
             },
         ]);
-        const options = { outputPath };
+        const options = { outputPath, databaseIds };
         try {
-            analyzeStringAttributes(config, options);
+            await analyzeStringAttributes(controller.adapter, controller.config, options);
             MessageFormatter.success("Analysis complete. Review the YAML plan, edit targetType/action as needed, then run Execute.", { prefix: "Analyze" });
         }
         catch (err) {

package/dist/main.js

@@ -469,6 +469,11 @@ const argv = yargs(hideBin(process.argv))
     alias: ["migrate-strings-output"],
     type: "string",
     description: "Output path for the migration plan (default: ./migrate-strings-plan.yaml)",
+})
+    .option("migrateStringsDbIds", {
+    alias: ["migrate-strings-db-ids"],
+    type: "string",
+    description: "Comma-separated database IDs to include in analysis (default: all)",
 })
     .option("migrateStringsKeepBackups", {
     alias: ["migrate-strings-keep-backups"],
@@ -648,14 +653,16 @@ async function main() {
         if (argv.migrateStringsAnalyze || argv.migrateStringsExecute) {
             const { analyzeStringAttributes, executeMigrationPlan } = await import("./migrations/migrateStrings.js");
             if (argv.migrateStringsAnalyze) {
-                if (!controller.config) {
-                    MessageFormatter.error("No Appwrite configuration found", undefined, {
-                        prefix: "Migration",
-                    });
+                if (!controller.adapter) {
+                    MessageFormatter.error("No database adapter available. Ensure config has valid credentials.", undefined, { prefix: "Migration" });
                     return;
                 }
-                analyzeStringAttributes(controller.config, {
+                const databaseIds = argv.migrateStringsDbIds
+                    ? argv.migrateStringsDbIds.split(",").map((s) => s.trim()).filter(Boolean)
+                    : undefined;
+                await analyzeStringAttributes(controller.adapter, controller.config, {
                     outputPath: argv.migrateStringsOutput,
+                    databaseIds,
                 });
             }
             else if (argv.migrateStringsExecute) {

package/dist/migrations/migrateStrings.d.ts

@@ -1,7 +1,7 @@
 import { type DatabaseAdapter } from "@njdamstra/appwrite-utils-helpers";
 import type { AppwriteConfig } from "@njdamstra/appwrite-utils";
 import { type MigrationPlan, type AnalyzeOptions, type ExecuteOptions } from "./migrateStringsTypes.js";
-export declare function analyzeStringAttributes(config: AppwriteConfig, options?: AnalyzeOptions): MigrationPlan;
+export declare function analyzeStringAttributes(adapter: DatabaseAdapter, config: AppwriteConfig, options?: AnalyzeOptions): Promise<MigrationPlan>;
 export declare function executeMigrationPlan(adapter: DatabaseAdapter, options: ExecuteOptions): Promise<{
     succeeded: number;
     failed: number;

package/dist/migrations/migrateStrings.js

@@ -8,55 +8,56 @@ import { MessageFormatter, tryAwaitWithRetry, } from "@njdamstra/appwrite-utils-
 import { ProgressManager } from "../shared/progressManager.js";
 import { MigrationPlanSchema, MigrationCheckpointSchema, suggestTargetType, generateBackupKey, } from "./migrateStringsTypes.js";
 // ────────────────────────────────────────────────────────
-// Phase 1: Analyze — offline, reads local YAML configs
+// Phase 1: Analyze — queries Appwrite server for real state
 // ────────────────────────────────────────────────────────
-export function analyzeStringAttributes(config, options = {}) {
-    const collections = [
-        ...(config.collections || []),
-        ...(config.tables || []),
-    ];
-    const databases = config.databases || [];
+export async function analyzeStringAttributes(adapter, config, options = {}) {
+    let databasesToScan = config.databases || [];
+    if (options.databaseIds?.length) {
+        databasesToScan = databasesToScan.filter(db => options.databaseIds.includes(db.$id));
+    }
+    const databases = databasesToScan;
+    if (databases.length === 0) {
+        MessageFormatter.warning("No databases configured. Nothing to analyze.", {
+            prefix: "Analyze",
+        });
+        return emptyPlan(config);
+    }
     const entries = [];
-    const collectionsSeen = new Set();
     for (const db of databases) {
-        // Find collections assigned to this database (or unassigned = applied to all)
-        const dbCollections = collections.filter((c) => {
-            const coll = c;
-            if (coll.databaseId)
-                return coll.databaseId === db.$id;
-            if (coll.databaseIds?.length)
-                return coll.databaseIds.includes(db.$id);
-            return true; // unassigned → applied to all databases
+        MessageFormatter.info(`Scanning database: ${db.name} (${db.$id})`, {
+            prefix: "Analyze",
         });
-        for (const coll of dbCollections) {
-            const collId = coll.$id || coll.name;
-            const dedupKey = `${db.$id}:${collId}`;
-            if (collectionsSeen.has(dedupKey))
-                continue;
-            collectionsSeen.add(dedupKey);
-            const attributes = coll.attributes || [];
-            const indexes = coll.indexes || [];
+        // Fetch all collections/tables from server
+        const tablesRes = await tryAwaitWithRetry(() => adapter.listTables({ databaseId: db.$id }));
+        const tables = tablesRes?.tables || tablesRes?.collections || tablesRes?.data || [];
+        for (const table of tables) {
+            const tableId = table.$id || table.key || table.name;
+            const tableName = table.name || tableId;
+            // Fetch full schema from server
+            const schemaRes = await tryAwaitWithRetry(() => adapter.getTable({ databaseId: db.$id, tableId }));
+            const attributes = schemaRes?.data?.columns || schemaRes?.data?.attributes || [];
+            // Fetch indexes from server
+            const indexRes = await tryAwaitWithRetry(() => adapter.listIndexes({ databaseId: db.$id, tableId }));
+            const indexes = indexRes?.data || [];
             for (const attr of attributes) {
                 if (attr.type !== "string")
                     continue;
-                const stringAttr = attr;
-                const size = stringAttr.size || 50;
-                const isEncrypted = !!stringAttr.encrypt;
+                const size = attr.size || 50;
+                const isEncrypted = !!attr.encrypt;
                 const isRequired = !!attr.required;
                 const isArray = !!attr.array;
-                const hasDefault = stringAttr.xdefault !== undefined && stringAttr.xdefault !== null;
+                const hasDefault = attr.xdefault !== undefined && attr.xdefault !== null;
                 // Find indexes that reference this attribute
                 const affectedIndexes = indexes
-                    .filter((idx) => idx.attributes.includes(attr.key))
+                    .filter((idx) => idx.attributes?.includes(attr.key))
                     .map((idx) => idx.key);
                 const hasIndex = affectedIndexes.length > 0;
                 const suggested = suggestTargetType(size, hasIndex);
-                // Build entry
                 const entry = {
                     databaseId: db.$id,
                     databaseName: db.name,
-                    collectionId: collId,
-                    collectionName: coll.name,
+                    collectionId: tableId,
+                    collectionName: tableName,
                     attributeKey: attr.key,
                     currentType: "string",
                     currentSize: size,
@@ -64,7 +65,7 @@ export function analyzeStringAttributes(config, options = {}) {
                     isArray,
                     isEncrypted,
                     hasDefault,
-                    defaultValue: hasDefault ? stringAttr.xdefault : undefined,
+                    defaultValue: hasDefault ? attr.xdefault : undefined,
                     suggestedType: suggested,
                     targetType: suggested,
                     targetSize: suggested === "varchar" ? size : undefined,
@@ -72,10 +73,8 @@ export function analyzeStringAttributes(config, options = {}) {
                     skipReason: isEncrypted ? "encrypted" : undefined,
                     indexesAffected: affectedIndexes,
                 };
-                // Warn if indexed attr gets non-varchar suggestion
-                if (hasIndex &&
-                    suggested !== "varchar" &&
-                    !isEncrypted) {
+                // Indexed attrs must stay varchar
+                if (hasIndex && suggested !== "varchar" && !isEncrypted) {
                     entry.targetType = "varchar";
                     entry.targetSize = size;
                 }
@@ -116,6 +115,22 @@ export function analyzeStringAttributes(config, options = {}) {
     printPlanSummary(plan);
     return plan;
 }
+function emptyPlan(config) {
+    return {
+        version: 1,
+        generatedAt: new Date().toISOString(),
+        appwriteEndpoint: config.appwriteEndpoint,
+        appwriteProject: config.appwriteProject,
+        summary: {
+            totalStringAttributes: 0,
+            toMigrate: 0,
+            toSkip: 0,
+            databaseCount: 0,
+            collectionCount: 0,
+        },
+        entries: [],
+    };
+}
 function printPlanSummary(plan) {
     const { summary } = plan;
     console.log("");

package/dist/migrations/migrateStringsTypes.d.ts

@@ -182,6 +182,7 @@ export type MigrationCheckpoint = z.infer<typeof MigrationCheckpointSchema>;
 export interface AnalyzeOptions {
     outputPath?: string;
     verbose?: boolean;
+    databaseIds?: string[];
 }
 export interface ExecuteOptions {
     planPath: string;

package/dist/migrations/migrateStringsTypes.js

@@ -97,16 +97,17 @@ export function suggestTargetType(size, hasIndex) {
 }
 // ── Helper: generate backup key with length limits ──
 const MAX_KEY_LENGTH = 36;
-const BACKUP_PREFIX = "_mig_";
+const BACKUP_PREFIX = "mig_";
 export function generateBackupKey(originalKey) {
     const candidate = `${BACKUP_PREFIX}${originalKey}`;
     if (candidate.length <= MAX_KEY_LENGTH) {
         return candidate;
     }
-    // Truncate + 4-char hash for uniqueness
+    // Truncate + 4-char hash for uniqueness: m_ + orig + _ + hash(4)
     const hash = simpleHash(originalKey);
-    const maxOrigLen = MAX_KEY_LENGTH - BACKUP_PREFIX.length - 1 - 4; // _mig_ + _ + hash4
-    return `_m_${originalKey.slice(0, maxOrigLen)}_${hash}`;
+    const TRUNC_PREFIX = "m_";
+    const maxOrigLen = MAX_KEY_LENGTH - TRUNC_PREFIX.length - 1 - 4;
+    return `${TRUNC_PREFIX}${originalKey.slice(0, maxOrigLen)}_${hash}`;
 }
 function simpleHash(str) {
     let h = 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@njdamstra/appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "1.11.0",
+  "version": "1.11.2",
   "main": "dist/main.js",
   "type": "module",
   "repository": {

package/src/cli/commands/migrateCommands.ts

@@ -17,7 +17,7 @@ export const migrateCommands = {
         message: "String attribute migration:",
         choices: [
           {
-            name: "Analyze — scan local configs, generate migration plan (YAML)",
+            name: "Analyze — scan Appwrite server, generate migration plan (YAML)",
             value: "analyze",
           },
           {
@@ -39,27 +39,38 @@ export const migrateCommands = {
 
   async analyzePhase(cli: InteractiveCLI): Promise<void> {
     const controller = (cli as any).controller;
-    if (!controller?.config) {
+    if (!controller?.adapter) {
       MessageFormatter.error(
-        "No configuration loaded. Make sure you have a valid .appwrite config.",
+        "No database adapter available. Ensure a server connection is established.",
         undefined,
         { prefix: "Analyze" }
       );
       return;
     }
 
-    const config = controller.config;
-    const collections = [
-      ...(config.collections || []),
-      ...(config.tables || []),
-    ];
-
-    if (collections.length === 0) {
-      MessageFormatter.warning(
-        "No collections/tables found in local config. Nothing to analyze.",
-        { prefix: "Analyze" }
-      );
-      return;
+    // Prompt for database selection
+    const allDatabases = controller.config.databases || [];
+    let databaseIds: string[] | undefined;
+    if (allDatabases.length > 1) {
+      const { selectedDbs } = await inquirer.prompt([
+        {
+          type: "checkbox",
+          name: "selectedDbs",
+          message: "Select databases to include in the analysis:",
+          choices: allDatabases.map((db: any) => ({
+            name: `${db.name} (${db.$id})`,
+            value: db.$id,
+            checked: true,
+          })),
+        },
+      ]);
+      if (selectedDbs.length === 0) {
+        MessageFormatter.warning("No databases selected. Aborting.", { prefix: "Analyze" });
+        return;
+      }
+      if (selectedDbs.length < allDatabases.length) {
+        databaseIds = selectedDbs;
+      }
     }
 
     // Prompt for output path
@@ -72,10 +83,10 @@ export const migrateCommands = {
       },
     ]);
 
-    const options: AnalyzeOptions = { outputPath };
+    const options: AnalyzeOptions = { outputPath, databaseIds };
 
     try {
-      analyzeStringAttributes(config, options);
+      await analyzeStringAttributes(controller.adapter, controller.config, options);
       MessageFormatter.success(
         "Analysis complete. Review the YAML plan, edit targetType/action as needed, then run Execute.",
         { prefix: "Analyze" }

package/src/main.ts

@@ -86,6 +86,7 @@ interface CliOptions {
   migrateStringsAnalyze?: boolean;
   migrateStringsExecute?: string;
   migrateStringsOutput?: string;
+  migrateStringsDbIds?: string;
   migrateStringsKeepBackups?: boolean;
   migrateStringsDryRun?: boolean;
 }
@@ -642,6 +643,11 @@ const argv = yargs(hideBin(process.argv))
     type: "string",
     description: "Output path for the migration plan (default: ./migrate-strings-plan.yaml)",
   })
+  .option("migrateStringsDbIds", {
+    alias: ["migrate-strings-db-ids"],
+    type: "string",
+    description: "Comma-separated database IDs to include in analysis (default: all)",
+  })
   .option("migrateStringsKeepBackups", {
     alias: ["migrate-strings-keep-backups"],
     type: "boolean",
@@ -881,14 +887,20 @@ async function main() {
       );
 
       if (argv.migrateStringsAnalyze) {
-        if (!controller.config) {
-          MessageFormatter.error("No Appwrite configuration found", undefined, {
-            prefix: "Migration",
-          });
+        if (!controller.adapter) {
+          MessageFormatter.error(
+            "No database adapter available. Ensure config has valid credentials.",
+            undefined,
+            { prefix: "Migration" }
+          );
           return;
         }
-        analyzeStringAttributes(controller.config, {
+        const databaseIds = argv.migrateStringsDbIds
+          ? argv.migrateStringsDbIds.split(",").map((s: string) => s.trim()).filter(Boolean)
+          : undefined;
+        await analyzeStringAttributes(controller.adapter, controller.config, {
           outputPath: argv.migrateStringsOutput,
+          databaseIds,
         });
       } else if (argv.migrateStringsExecute) {
         if (!controller.adapter) {

package/src/migrations/migrateStrings.ts

@@ -9,11 +9,7 @@ import {
   MessageFormatter,
   tryAwaitWithRetry,
 } from "@njdamstra/appwrite-utils-helpers";
-import type {
-  AppwriteConfig,
-  Attribute,
-  Index,
-} from "@njdamstra/appwrite-utils";
+import type { AppwriteConfig } from "@njdamstra/appwrite-utils";
 import { ProgressManager } from "../shared/progressManager.js";
 import {
   type MigrationPlan,
@@ -30,65 +26,80 @@ import {
 } from "./migrateStringsTypes.js";
 
 // ────────────────────────────────────────────────────────
-// Phase 1: Analyze — offline, reads local YAML configs
+// Phase 1: Analyze — queries Appwrite server for real state
 // ────────────────────────────────────────────────────────
 
-export function analyzeStringAttributes(
+export async function analyzeStringAttributes(
+  adapter: DatabaseAdapter,
   config: AppwriteConfig,
   options: AnalyzeOptions = {}
-): MigrationPlan {
-  const collections = [
-    ...(config.collections || []),
-    ...(config.tables || []),
-  ];
-  const databases = config.databases || [];
+): Promise<MigrationPlan> {
+  let databasesToScan = config.databases || [];
+  if (options.databaseIds?.length) {
+    databasesToScan = databasesToScan.filter(db => options.databaseIds!.includes(db.$id));
+  }
+  const databases = databasesToScan;
+  if (databases.length === 0) {
+    MessageFormatter.warning("No databases configured. Nothing to analyze.", {
+      prefix: "Analyze",
+    });
+    return emptyPlan(config);
+  }
 
   const entries: MigrationPlanEntry[] = [];
-  const collectionsSeen = new Set<string>();
 
   for (const db of databases) {
-    // Find collections assigned to this database (or unassigned = applied to all)
-    const dbCollections = collections.filter((c) => {
-      const coll = c as any;
-      if (coll.databaseId) return coll.databaseId === db.$id;
-      if (coll.databaseIds?.length) return coll.databaseIds.includes(db.$id);
-      return true; // unassigned → applied to all databases
+    MessageFormatter.info(`Scanning database: ${db.name} (${db.$id})`, {
+      prefix: "Analyze",
     });
 
-    for (const coll of dbCollections) {
-      const collId = (coll as any).$id || coll.name;
-      const dedupKey = `${db.$id}:${collId}`;
-      if (collectionsSeen.has(dedupKey)) continue;
-      collectionsSeen.add(dedupKey);
+    // Fetch all collections/tables from server
+    const tablesRes = await tryAwaitWithRetry(() =>
+      adapter.listTables({ databaseId: db.$id })
+    );
+    const tables: any[] =
+      tablesRes?.tables || tablesRes?.collections || tablesRes?.data || [];
+
+    for (const table of tables) {
+      const tableId: string = table.$id || table.key || table.name;
+      const tableName: string = table.name || tableId;
 
-      const attributes: Attribute[] = (coll as any).attributes || [];
-      const indexes: Index[] = (coll as any).indexes || [];
+      // Fetch full schema from server
+      const schemaRes = await tryAwaitWithRetry(() =>
+        adapter.getTable({ databaseId: db.$id, tableId })
+      );
+      const attributes: any[] =
+        schemaRes?.data?.columns || schemaRes?.data?.attributes || [];
+
+      // Fetch indexes from server
+      const indexRes = await tryAwaitWithRetry(() =>
+        adapter.listIndexes({ databaseId: db.$id, tableId })
+      );
+      const indexes: any[] = indexRes?.data || [];
 
       for (const attr of attributes) {
         if (attr.type !== "string") continue;
 
-        const stringAttr = attr as any;
-        const size: number = stringAttr.size || 50;
-        const isEncrypted = !!stringAttr.encrypt;
+        const size: number = attr.size || 50;
+        const isEncrypted = !!(attr as any).encrypt;
         const isRequired = !!attr.required;
         const isArray = !!attr.array;
         const hasDefault =
-          stringAttr.xdefault !== undefined && stringAttr.xdefault !== null;
+          attr.xdefault !== undefined && attr.xdefault !== null;
 
         // Find indexes that reference this attribute
         const affectedIndexes = indexes
-          .filter((idx) => idx.attributes.includes(attr.key))
-          .map((idx) => idx.key);
+          .filter((idx: any) => idx.attributes?.includes(attr.key))
+          .map((idx: any) => idx.key);
         const hasIndex = affectedIndexes.length > 0;
 
         const suggested = suggestTargetType(size, hasIndex);
 
-        // Build entry
         const entry: MigrationPlanEntry = {
           databaseId: db.$id,
           databaseName: db.name,
-          collectionId: collId,
-          collectionName: coll.name,
+          collectionId: tableId,
+          collectionName: tableName,
           attributeKey: attr.key,
           currentType: "string",
           currentSize: size,
@@ -96,7 +107,7 @@ export function analyzeStringAttributes(
           isArray,
           isEncrypted,
           hasDefault,
-          defaultValue: hasDefault ? stringAttr.xdefault : undefined,
+          defaultValue: hasDefault ? attr.xdefault : undefined,
           suggestedType: suggested,
           targetType: suggested,
           targetSize: suggested === "varchar" ? size : undefined,
@@ -105,12 +116,8 @@ export function analyzeStringAttributes(
           indexesAffected: affectedIndexes,
         };
 
-        // Warn if indexed attr gets non-varchar suggestion
-        if (
-          hasIndex &&
-          suggested !== "varchar" &&
-          !isEncrypted
-        ) {
+        // Indexed attrs must stay varchar
+        if (hasIndex && suggested !== "varchar" && !isEncrypted) {
           entry.targetType = "varchar";
           entry.targetSize = size;
         }
@@ -161,6 +168,23 @@ export function analyzeStringAttributes(
   return plan;
 }
 
+function emptyPlan(config: AppwriteConfig): MigrationPlan {
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    appwriteEndpoint: config.appwriteEndpoint,
+    appwriteProject: config.appwriteProject,
+    summary: {
+      totalStringAttributes: 0,
+      toMigrate: 0,
+      toSkip: 0,
+      databaseCount: 0,
+      collectionCount: 0,
+    },
+    entries: [],
+  };
+}
+
 function printPlanSummary(plan: MigrationPlan): void {
   const { summary } = plan;
   console.log("");

package/src/migrations/migrateStringsTypes.ts

@@ -108,6 +108,7 @@ export type MigrationCheckpoint = z.infer<typeof MigrationCheckpointSchema>;
 export interface AnalyzeOptions {
   outputPath?: string;
   verbose?: boolean;
+  databaseIds?: string[];
 }
 
 export interface ExecuteOptions {
@@ -136,17 +137,18 @@ export function suggestTargetType(
 // ── Helper: generate backup key with length limits ──
 
 const MAX_KEY_LENGTH = 36;
-const BACKUP_PREFIX = "_mig_";
+const BACKUP_PREFIX = "mig_";
 
 export function generateBackupKey(originalKey: string): string {
   const candidate = `${BACKUP_PREFIX}${originalKey}`;
   if (candidate.length <= MAX_KEY_LENGTH) {
     return candidate;
   }
-  // Truncate + 4-char hash for uniqueness
+  // Truncate + 4-char hash for uniqueness: m_ + orig + _ + hash(4)
   const hash = simpleHash(originalKey);
-  const maxOrigLen = MAX_KEY_LENGTH - BACKUP_PREFIX.length - 1 - 4; // _mig_ + _ + hash4
-  return `_m_${originalKey.slice(0, maxOrigLen)}_${hash}`;
+  const TRUNC_PREFIX = "m_";
+  const maxOrigLen = MAX_KEY_LENGTH - TRUNC_PREFIX.length - 1 - 4;
+  return `${TRUNC_PREFIX}${originalKey.slice(0, maxOrigLen)}_${hash}`;
 }
 
 function simpleHash(str: string): string {