appwrite-utils-cli 0.0.261 → 0.0.263

package/src/migrations/databases.ts

@@ -0,0 +1,25 @@
+import { Databases, Query, type Models } from "node-appwrite";
+
+export const fetchAllDatabases = async (
+  database: Databases
+): Promise<Models.Database[]> => {
+  const databases = await database.list([Query.limit(25)]);
+  const allDatabases = databases.databases;
+  let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
+  if (databases.databases.length < 25) {
+    return allDatabases;
+  } else {
+    while (lastDatabaseId) {
+      const databases = await database.list([
+        Query.limit(25),
+        Query.cursorAfter(lastDatabaseId),
+      ]);
+      allDatabases.push(...databases.databases);
+      if (databases.databases.length < 25) {
+        break;
+      }
+      lastDatabaseId = databases.databases[databases.databases.length - 1].$id;
+    }
+  }
+  return allDatabases;
+};

package/src/migrations/importController.ts

@@ -236,6 +236,9 @@ export class ImportController {
           if (item.finalData.hasOwnProperty("docId")) {
             delete item.finalData.docId;
           }
+          if (!item.finalData) {
+            return Promise.resolve();
+          }
           return this.database
             .createDocument(db.$id, collection.$id, id, item.finalData)
             .then(() => {

package/src/migrations/importDataActions.ts

@@ -45,7 +45,7 @@ export class ImportDataActions {
     this.afterImportActionsDefinitions = afterImportActionsDefinitions;
   }
 
-  async runConverterFunctions(item: any, attributeMappings: AttributeMappings) {
+  runConverterFunctions(item: any, attributeMappings: AttributeMappings) {
     const conversionSchema = attributeMappings.reduce((schema, mapping) => {
       schema[mapping.targetKey] = (originalValue: any) => {
         return mapping.converters.reduce((value, converterName) => {

package/src/migrations/schema.ts

@@ -1,4 +1,4 @@
-import { ID, IndexType } from "node-appwrite";
+import { ID, IndexType, Permission } from "node-appwrite";
 import { z } from "zod";
 
 const stringAttributeSchema = z.object({
@@ -376,6 +376,8 @@ export const indexSchema = z.object({
   orders: z.array(z.string()).optional(),
 });
 
+export const indexesSchema = z.array(indexSchema);
+
 export type Index = z.infer<typeof indexSchema>;
 
 export const AttributeMappingsSchema = z.array(
@@ -435,6 +437,28 @@ export const AttributeMappingsSchema = z.array(
   })
 );
 
+export const idMappingSchema = z.array(
+  z.object({
+    sourceField: z
+      .string()
+      .describe(
+        "The key of the data in the import data to match in the current data"
+      ),
+    fieldToSet: z
+      .string()
+      .optional()
+      .describe(
+        "The field to set in the target collection, if different from sourceField"
+      ),
+    targetField: z
+      .string()
+      .describe(
+        "The field in the target collection to match with sourceField that will then be updated"
+      ),
+    targetCollection: z.string().describe("The collection to search"),
+  })
+);
+
 export const importDefSchema = z
   .object({
     type: z
@@ -457,28 +481,7 @@ export const importDefSchema = z
       .describe(
         "The field in the import data representing the primary key for this import data (if any)"
       ),
-    idMappings: z
-      .array(
-        z.object({
-          sourceField: z
-            .string()
-            .describe(
-              "The key of the data in the import data to match in the current data"
-            ),
-          fieldToSet: z
-            .string()
-            .optional()
-            .describe(
-              "The field to set in the target collection, if different from sourceField"
-            ),
-          targetField: z
-            .string()
-            .describe(
-              "The field in the target collection to match with sourceField that will then be updated"
-            ),
-          targetCollection: z.string().describe("The collection to search"),
-        })
-      )
+    idMappings: idMappingSchema
       .optional()
       .describe("The id mappings for the attribute to map ID's to"),
     updateMapping: z
@@ -509,12 +512,45 @@ export const importDefSchemas = z
   .default([])
   .describe("The import definitions for the database");
 
+export const permissionSchema = z
+  .object({
+    permission: z.string(),
+    target: z.string(),
+  })
+  .or(
+    z.string().transform((val) => {
+      const trimmedVal = val.trim();
+      // Adjusted regex to match double quotes
+      const match = trimmedVal.match(/^(\w+)\("([^"]+)"\)$/);
+      if (!match) {
+        throw new Error(`Invalid permission format: ${trimmedVal}`);
+      }
+      return {
+        permission: match[1],
+        target: match[2],
+      };
+    })
+  );
+
+export const permissionsSchema = z.array(permissionSchema).optional();
+
+export const attributesSchema = z.array(attributeSchema).default([]);
+
 export const collectionSchema = z.object({
+  name: z.string().describe("The name of the collection"),
   $id: z
     .string()
     .optional()
     .default(ID.unique())
     .describe("The ID of the collection, auto generated if not provided"),
+  enabled: z
+    .boolean()
+    .default(true)
+    .describe("Whether the collection is enabled or not"),
+  documentSecurity: z
+    .boolean()
+    .default(false)
+    .describe("Whether document security is enabled or not"),
   $createdAt: z.string(),
   $updatedAt: z.string(),
   $permissions: z
@@ -526,19 +562,6 @@ export const collectionSchema = z.object({
     )
     .default([])
     .describe("The permissions of the collection"),
-  databaseId: z
-    .string()
-    .optional()
-    .describe("The ID of the database the collection belongs to"),
-  name: z.string().describe("The name of the collection"),
-  enabled: z
-    .boolean()
-    .default(true)
-    .describe("Whether the collection is enabled or not"),
-  documentSecurity: z
-    .boolean()
-    .default(false)
-    .describe("Whether document security is enabled or not"),
   attributes: z
     .array(attributeSchema)
     .default([])
@@ -548,6 +571,10 @@ export const collectionSchema = z.object({
     .default([])
     .describe("The indexes of the collection"),
   importDefs: importDefSchemas,
+  databaseId: z
+    .string()
+    .optional()
+    .describe("The ID of the database the collection belongs to"),
 });
 
 export const CollectionCreateSchema = collectionSchema.omit({
@@ -622,5 +649,7 @@ export type ConfigDatabases = AppwriteConfig["databases"];
 export type ConfigDatabase = ConfigDatabases[number];
 export type ImportDefs = z.infer<typeof importDefSchemas>;
 export type ImportDef = z.infer<typeof importDefSchema>;
+export type IdMappings = z.infer<typeof idMappingSchema>;
+export type IdMapping = IdMappings[number];
 export type AttributeMappings = z.infer<typeof AttributeMappingsSchema>;
 export type AttributeMapping = AttributeMappings[number];

package/src/migrations/schemaStrings.ts

@@ -7,6 +7,7 @@ import type {
 import { z } from "zod";
 import fs from "fs";
 import path from "path";
+import { dump } from "js-yaml";
 
 interface RelationshipDetail {
   parentCollection: string;
@@ -28,6 +29,16 @@ export class SchemaGenerator {
     this.extractRelationships();
   }
 
+  public updateYamlSchemas(): void {
+    // Output this.config to a YAML file at appwriteFolderPath/appwriteConfig.yaml
+    let finalConfig = this.config;
+    finalConfig.appwriteClient = null;
+    const yamlConfig = finalConfig;
+    const yamlPath = path.join(this.appwriteFolderPath, "appwriteConfig.yaml");
+    fs.writeFileSync(yamlPath, dump(yamlConfig), { encoding: "utf-8" });
+    console.log(`YAML written to ${yamlPath}`);
+  }
+
   private extractRelationships(): void {
     this.config.collections.forEach((collection) => {
       collection.attributes.forEach((attr) => {

package/src/utils/helperFunctions.ts

@@ -2,6 +2,8 @@ import type { AppwriteConfig } from "../types.js";
 import type { Models, Storage } from "node-appwrite";
 import fs from "node:fs";
 import path from "node:path";
+import type { CollectionImportData } from "src/migrations/dataLoader.js";
+import type { ConfigCollection } from "src/migrations/schema.js";
 
 export const toPascalCase = (str: string): string => {
   return (
@@ -109,3 +111,18 @@ export const getFileDownloadUrl = (
     jwt ? `&jwt=${jwt.jwt}` : ""
   }`;
 };
+
+export const finalizeByAttributeMap = async (
+  appwriteFolderPath: string,
+  collection: ConfigCollection,
+  item: CollectionImportData["data"][number]
+) => {
+  const schemaFolderPath = path.join(appwriteFolderPath, "schemas");
+  const zodSchema = await import(
+    `${schemaFolderPath}/${toCamelCase(collection.name)}.ts`
+  );
+  return zodSchema.parse({
+    ...item.context,
+    ...item.finalData,
+  });
+};

package/src/utilsController.ts

@@ -23,6 +23,7 @@ import {
 } from "./migrations/validationRules.js";
 import { ImportController } from "./migrations/importController.js";
 import _ from "lodash";
+import { AppwriteToX } from "./migrations/appwriteToX.js";
 
 async function loadConfig(configPath: string) {
   if (!fs.existsSync(configPath)) {
@@ -35,6 +36,7 @@ async function loadConfig(configPath: string) {
 }
 
 export interface SetupOptions {
+  sync: boolean;
   runProd: boolean;
   runStaging: boolean;
   runDev: boolean;
@@ -127,6 +129,13 @@ export class UtilsController {
       throw new Error("Database or storage not initialized");
     }
 
+    if (options.sync) {
+      console.log("Starting synchronization with server...");
+      const appwriteToX = new AppwriteToX(this.config, this.appwriteFolderPath);
+      await appwriteToX.toSchemas();
+      console.log("Synchronization complete, YAML and Schemas updated");
+    }
+
     // Start the setup
     console.log(
       "Starting setup, this step sets up migrations, runs backup, wipes databases, and updates schemas (depending on your options)..."