appwrite-utils-cli 1.7.8 → 1.8.1

package/src/shared/attributeMapper.ts

@@ -0,0 +1,229 @@
+import type { CreateAttributeParams, UpdateAttributeParams } from "../adapters/DatabaseAdapter.js";
+import type { Attribute } from "appwrite-utils";
+
+function ensureNumber(n: any): number | undefined {
+  if (n === null || n === undefined) return undefined;
+  const num = Number(n);
+  return Number.isFinite(num) ? num : undefined;
+}
+
+/**
+ * Map a schema Attribute into DatabaseAdapter CreateAttributeParams
+ * Only includes fields valid for the specific type to satisfy TS unions.
+ * Also normalizes min/max ordering for numeric types to avoid server errors.
+ */
+export function mapToCreateAttributeParams(
+  attr: Attribute,
+  base: { databaseId: string; tableId: string }
+): CreateAttributeParams {
+  const type = String((attr as any).type || "").toLowerCase();
+  const required = !!(attr as any).required;
+  const array = !!(attr as any).array;
+  const xdefault = (attr as any).xdefault;
+  const encrypt = (attr as any).encrypted ?? (attr as any).encrypt;
+
+  // Numeric helpers
+  const rawMin = ensureNumber((attr as any).min);
+  const rawMax = ensureNumber((attr as any).max);
+  let min = rawMin;
+  let max = rawMax;
+  if (min !== undefined && max !== undefined && min >= max) {
+    // Swap to satisfy server-side validation
+    const tmp = min;
+    min = Math.min(min, max);
+    max = Math.max(tmp, max);
+    if (min === max) {
+      // If still equal, unset max to avoid error
+      max = undefined;
+    }
+  }
+
+  switch (type) {
+    case "string":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        size: (attr as any).size ?? 255,
+        required,
+        default: xdefault,
+        array,
+        encrypt: !!encrypt,
+      };
+
+    case "integer":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+        min,
+        max,
+      };
+
+    case "double":
+    case "float":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+        min,
+        max,
+      };
+
+    case "boolean":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+      };
+
+    case "datetime":
+    case "email":
+    case "ip":
+    case "url":
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+      };
+
+    case "enum":
+      {
+        const elements = (attr as any).elements;
+        if (!Array.isArray(elements) || elements.length === 0) {
+          // Creating an enum without elements is invalid – fail fast with clear messaging
+          throw new Error(
+            `Enum attribute '${(attr as any).key}' requires a non-empty 'elements' array for creation`
+          );
+        }
+      }
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+        default: xdefault,
+        array,
+        elements: (attr as any).elements,
+      };
+
+    case "relationship": {
+      // Relationship attributes require related collection and metadata
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        relatedCollection: (attr as any).relatedCollection,
+        relationType: (attr as any).relationType,
+        twoWay: (attr as any).twoWay,
+        twoWayKey: (attr as any).twoWayKey,
+        onDelete: (attr as any).onDelete,
+        side: (attr as any).side,
+      } as unknown as CreateAttributeParams;
+    }
+
+    default:
+      return {
+        databaseId: base.databaseId,
+        tableId: base.tableId,
+        key: attr.key,
+        type,
+        required,
+      } as CreateAttributeParams;
+  }
+}
+
+/**
+ * Map a schema Attribute into DatabaseAdapter UpdateAttributeParams
+ * Omits fields that are not explicitly provided, and guards enum updates
+ * so we never send an empty elements array (preserve existing on server).
+ */
+export function mapToUpdateAttributeParams(
+  attr: Attribute,
+  base: { databaseId: string; tableId: string }
+): UpdateAttributeParams {
+  const type = String((attr as any).type || "").toLowerCase();
+  const params: UpdateAttributeParams = {
+    databaseId: base.databaseId,
+    tableId: base.tableId,
+    key: (attr as any).key,
+  };
+
+  const setIfDefined = <K extends keyof UpdateAttributeParams>(
+    key: K,
+    value: UpdateAttributeParams[K]
+  ) => {
+    if (value !== undefined) (params as any)[key] = value;
+  };
+
+  // Common fields
+  setIfDefined("type", type);
+  setIfDefined("required", (attr as any).required);
+  // Only send default if explicitly provided and not on required
+  if (!(attr as any).required && (attr as any).xdefault !== undefined) {
+    setIfDefined("default", (attr as any).xdefault as any);
+  }
+  setIfDefined("array", (attr as any).array);
+  // encrypt only applies to string types
+  if (type === "string") setIfDefined("encrypt", (attr as any).encrypted ?? (attr as any).encrypt);
+
+  // Numeric normalization
+  const toNum = (n: any) => (n === null || n === undefined ? undefined : (Number(n)));
+  let min = toNum((attr as any).min);
+  let max = toNum((attr as any).max);
+  if (min !== undefined && max !== undefined && min >= max) {
+    const tmp = min;
+    min = Math.min(min, max);
+    max = Math.max(tmp, max);
+    if (min === max) max = undefined;
+  }
+
+  switch (type) {
+    case "string":
+      setIfDefined("size", (attr as any).size);
+      break;
+    case "integer":
+    case "float":
+    case "double":
+      setIfDefined("min", min);
+      setIfDefined("max", max);
+      break;
+    case "enum": {
+      const elements = (attr as any).elements;
+      if (Array.isArray(elements) && elements.length > 0) {
+        // Only include when non-empty; otherwise preserve existing on server
+        setIfDefined("elements", elements as string[]);
+      }
+      break;
+    }
+    case "relationship": {
+      setIfDefined("relatedCollection", (attr as any).relatedCollection);
+      setIfDefined("relationType", (attr as any).relationType);
+      setIfDefined("twoWay", (attr as any).twoWay);
+      setIfDefined("twoWayKey", (attr as any).twoWayKey);
+      setIfDefined("onDelete", (attr as any).onDelete);
+      break;
+    }
+  }
+
+  return params;
+}

package/src/shared/selectionDialogs.ts

@@ -244,12 +244,13 @@ export class SelectionDialogs {
         return; // Skip configured databases if only allowing new ones
       }
 
-      choices.push({
-        name,
-        value: database.$id,
-        short: database.name,
-        checked: defaultSelected.includes(database.$id) || (!allowNewOnly && isConfigured)
-      });
+      choices.push({
+        name,
+        value: database.$id,
+        short: database.name,
+        // Do not preselect anything unless explicitly provided
+        checked: defaultSelected.includes(database.$id)
+      });
     });
 
     if (choices.length === 0) {
@@ -327,12 +328,13 @@ export class SelectionDialogs {
         return; // Skip configured tables if only allowing new ones
       }
 
-      choices.push({
-        name,
-        value: table.$id,
-        short: table.name,
-        checked: defaultSelected.includes(table.$id) || (!allowNewOnly && isConfigured)
-      });
+      choices.push({
+        name,
+        value: table.$id,
+        short: table.name,
+        // Do not preselect anything unless explicitly provided
+        checked: defaultSelected.includes(table.$id)
+      });
     });
 
     if (choices.length === 0) {
@@ -436,12 +438,13 @@ export class SelectionDialogs {
               return; // Skip configured buckets if only allowing new ones
             }
 
-            choices.push({
-              name: `  ${name}`,
-              value: bucket.$id,
-              short: bucket.name,
-              checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
-            });
+            choices.push({
+              name: `  ${name}`,
+              value: bucket.$id,
+              short: bucket.name,
+              // Do not preselect anything unless explicitly provided
+              checked: defaultSelected.includes(bucket.$id)
+            });
           });
         }
       });
@@ -480,12 +483,13 @@ export class SelectionDialogs {
           return; // Skip configured buckets if only allowing new ones
         }
 
-        choices.push({
-          name,
-          value: bucket.$id,
-          short: bucket.name,
-          checked: defaultSelected.includes(bucket.$id) || (!allowNewOnly && isConfigured)
-        });
+        choices.push({
+          name,
+          value: bucket.$id,
+          short: bucket.name,
+          // Do not preselect anything unless explicitly provided
+          checked: defaultSelected.includes(bucket.$id)
+        });
       });
     }
 
@@ -520,8 +524,37 @@ export class SelectionDialogs {
   /**
    * Shows final confirmation dialog with sync selection summary
    */
-  static async confirmSyncSelection(selectionSummary: SyncSelectionSummary): Promise<boolean> {
-    MessageFormatter.banner("Sync Selection Summary", "Review your selections before proceeding");
+  static async confirmSyncSelection(
+    selectionSummary: SyncSelectionSummary,
+    operationType: 'push' | 'pull' | 'sync' = 'sync'
+  ): Promise<boolean> {
+    const labels = {
+      push: {
+        banner: "Push Selection Summary",
+        subtitle: "Review selections before pushing to Appwrite",
+        confirm: "Proceed with push operation?",
+        success: "Push operation confirmed.",
+        cancel: "Push operation cancelled."
+      },
+      pull: {
+        banner: "Pull Selection Summary",
+        subtitle: "Review selections before pulling from Appwrite",
+        confirm: "Proceed with pull operation?",
+        success: "Pull operation confirmed.",
+        cancel: "Pull operation cancelled."
+      },
+      sync: {
+        banner: "Sync Selection Summary",
+        subtitle: "Review your selections before proceeding",
+        confirm: "Proceed with sync operation?",
+        success: "Sync operation confirmed.",
+        cancel: "Sync operation cancelled."
+      }
+    };
+
+    const label = labels[operationType];
+
+    MessageFormatter.banner(label.banner, label.subtitle);
 
     // Database summary
     console.log(chalk.bold.cyan("\n📊 Databases:"));
@@ -563,20 +596,20 @@ export class SelectionDialogs {
     const { confirmed } = await inquirer.prompt([{
       type: 'confirm',
       name: 'confirmed',
-      message: chalk.green.bold('Proceed with sync operation?'),
+      message: chalk.green.bold(label.confirm),
       default: true
     }]);
 
     if (confirmed) {
-      MessageFormatter.success("Sync operation confirmed.", { skipLogging: true });
-      logger.info("Sync selection confirmed", {
+      MessageFormatter.success(label.success, { skipLogging: true });
+      logger.info(`${operationType} selection confirmed`, {
         databases: selectionSummary.totalDatabases,
         tables: selectionSummary.totalTables,
         buckets: selectionSummary.totalBuckets
       });
     } else {
-      MessageFormatter.warning("Sync operation cancelled.", { skipLogging: true });
-      logger.info("Sync selection cancelled by user");
+      MessageFormatter.warning(label.cancel, { skipLogging: true });
+      logger.info(`${operationType} selection cancelled by user`);
     }
 
     return confirmed;
@@ -713,4 +746,4 @@ export class SelectionDialogs {
     MessageFormatter.success(message, { skipLogging: true });
     logger.info(`Selection dialog success: ${message}`);
   }
-}
+}

package/src/utils/configDiscovery.ts

@@ -1,6 +1,10 @@
 import path from "path";
 import fs from "fs";
-import { type CollectionCreate, type Collection } from "appwrite-utils";
+import {
+  CollectionCreateSchema,
+  type CollectionCreate,
+  type Collection
+} from "appwrite-utils";
 import { register } from "tsx/esm/api";
 import { pathToFileURL } from "node:url";
 import yaml from "js-yaml";
@@ -216,7 +220,7 @@ export const loadYamlCollection = (filePath: string): CollectionCreate | null =>
     const parsedCollection = YamlCollectionSchema.parse(yamlData);
 
     // Convert YAML collection to CollectionCreate format
-    const collection: CollectionCreate = {
+    const collectionInput: CollectionCreate = {
       name: parsedCollection.name,
       $id: parsedCollection.id || parsedCollection.name.toLowerCase().replace(/\s+/g, '_'),
       documentSecurity: parsedCollection.documentSecurity,
@@ -241,7 +245,7 @@ export const loadYamlCollection = (filePath: string): CollectionCreate | null =>
         twoWayKey: attr.twoWayKey,
         onDelete: attr.onDelete as any,
         side: attr.side as any,
-        encrypted: (attr as any).encrypt,
+        encrypt: (attr as any).encrypt,
         format: (attr as any).format
       })),
       indexes: parsedCollection.indexes.map(idx => ({
@@ -253,6 +257,8 @@ export const loadYamlCollection = (filePath: string): CollectionCreate | null =>
       importDefs: parsedCollection.importDefs && Array.isArray(parsedCollection.importDefs) && parsedCollection.importDefs.length > 0 ? parsedCollection.importDefs : []
     };
 
+    const collection = CollectionCreateSchema.parse(collectionInput);
+
     return collection;
   } catch (error) {
     MessageFormatter.error(`Error loading YAML collection from ${filePath}`, error as Error, { prefix: "Config" });