appwrite-utils-cli 0.0.1

package/src/migrations/schemaStrings.ts

@@ -0,0 +1,310 @@
+import { toCamelCase, toPascalCase } from "../utils/index.js";
+import type {
+  AppwriteConfig,
+  Attribute,
+  RelationshipAttribute,
+} from "./schema.js";
+import { z } from "zod";
+import fs from "fs";
+import path from "path";
+
+interface RelationshipDetail {
+  parentCollection: string;
+  childCollection: string;
+  parentKey: string;
+  childKey: string;
+  isArray: boolean;
+  isChild: boolean;
+}
+
+export class SchemaGenerator {
+  private relationshipMap = new Map<string, RelationshipDetail[]>();
+  private config: AppwriteConfig;
+  private appwriteFolderPath: string;
+
+  constructor(config: AppwriteConfig, appwriteFolderPath: string) {
+    this.config = config;
+    this.appwriteFolderPath = appwriteFolderPath;
+    this.extractRelationships();
+  }
+
+  private extractRelationships(): void {
+    this.config.collections.forEach((collection) => {
+      collection.attributes.forEach((attr) => {
+        if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
+          const relationshipAttr = attr as RelationshipAttribute;
+          console.log(`Extracting relationship: ${attr.key}`);
+          let isArrayParent = false;
+          let isArrayChild = false;
+          switch (relationshipAttr.relationType) {
+            case "oneToMany":
+              isArrayParent = true;
+              isArrayChild = false;
+              break;
+            case "manyToMany":
+              isArrayParent = true;
+              isArrayChild = true;
+              break;
+            case "oneToOne":
+              isArrayParent = false;
+              isArrayChild = false;
+              break;
+            case "manyToOne":
+              isArrayParent = false;
+              isArrayChild = true;
+              break;
+            default:
+              break;
+          }
+          this.addRelationship(
+            collection.name,
+            relationshipAttr.relatedCollection,
+            attr.key,
+            relationshipAttr.twoWayKey,
+            isArrayParent,
+            isArrayChild
+          );
+        }
+      });
+    });
+  }
+
+  private addRelationship(
+    parentCollection: string,
+    childCollection: string,
+    parentKey: string,
+    childKey: string,
+    isArrayParent: boolean,
+    isArrayChild: boolean
+  ): void {
+    const relationshipsChild = this.relationshipMap.get(childCollection) || [];
+    const relationshipsParent =
+      this.relationshipMap.get(parentCollection) || [];
+    relationshipsParent.push({
+      parentCollection,
+      childCollection,
+      parentKey,
+      childKey,
+      isArray: isArrayParent,
+      isChild: false,
+    });
+    relationshipsChild.push({
+      parentCollection,
+      childCollection,
+      parentKey,
+      childKey,
+      isArray: isArrayChild,
+      isChild: true,
+    });
+    this.relationshipMap.set(childCollection, relationshipsChild);
+    this.relationshipMap.set(parentCollection, relationshipsParent);
+  }
+
+  public generateSchemas(): void {
+    this.config.collections.forEach((collection) => {
+      const schemaString = this.createSchemaString(
+        collection.name,
+        collection.attributes
+      );
+      const camelCaseName = toCamelCase(collection.name);
+      const schemaPath = path.join(
+        this.appwriteFolderPath,
+        "schemas",
+        `${camelCaseName}.ts`
+      );
+      fs.writeFileSync(schemaPath, schemaString, { encoding: "utf-8" });
+      console.log(`Schema written to ${schemaPath}`);
+    });
+  }
+
+  createSchemaString = (name: string, attributes: Attribute[]): string => {
+    const pascalName = toPascalCase(name);
+    let imports = `import { z } from "zod";\n`;
+
+    // Use the relationshipMap to find related collections
+    const relationshipDetails = this.relationshipMap.get(name) || [];
+    const relatedCollections = relationshipDetails.map((detail) => {
+      const relatedCollectionName = detail.isChild
+        ? detail.parentCollection
+        : detail.childCollection;
+      const key = detail.isChild ? detail.childKey : detail.parentKey;
+      const isArray = detail.isArray ? "array" : "";
+      return [relatedCollectionName, key, isArray];
+    });
+
+    console.log(relatedCollections);
+
+    let relatedTypes = "";
+    let relatedTypesLazy = "";
+    let curNum = 0;
+    let maxNum = relatedCollections.length;
+    relatedCollections.forEach((relatedCollection) => {
+      const relatedPascalName = toPascalCase(relatedCollection[0]);
+      const relatedCamelName = toCamelCase(relatedCollection[0]);
+      curNum++;
+      let endNameTypes = relatedPascalName;
+      let endNameLazy = `${relatedPascalName}Schema`;
+      if (relatedCollection[2] === "array") {
+        endNameTypes += "[]";
+        endNameLazy += ".array()";
+      }
+      endNameLazy += ".nullish()";
+      imports += `import { ${relatedPascalName}Schema, type ${relatedPascalName} } from "./${relatedCamelName}";\n`;
+      relatedTypes += `${relatedCollection[1]}?: ${endNameTypes};\n`;
+      if (relatedTypes.length > 0 && curNum !== maxNum) {
+        relatedTypes += "  ";
+      }
+      relatedTypesLazy += `${relatedCollection[1]}: z.lazy(() => ${endNameLazy}),\n`;
+      if (relatedTypesLazy.length > 0 && curNum !== maxNum) {
+        relatedTypesLazy += "  ";
+      }
+    });
+
+    let schemaString = `${imports}\n\n`;
+    schemaString += `export const ${pascalName}SchemaBase = z.object({\n`;
+    schemaString += `  $id: z.string().optional(),\n`;
+    schemaString += `  $createdAt: z.date().or(z.string()).optional(),\n`;
+    schemaString += `  $updatedAt: z.date().or(z.string()).optional(),\n`;
+    for (const attribute of attributes) {
+      if (attribute.type === "relationship") {
+        continue;
+      }
+      schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
+    }
+    schemaString += `});\n\n`;
+    schemaString += `export type ${pascalName}Base = z.infer<typeof ${pascalName}SchemaBase>`;
+    if (relatedTypes.length > 0) {
+      schemaString += ` & {\n  ${relatedTypes}};\n\n`;
+    } else {
+      schemaString += `;\n\n`;
+    }
+    schemaString += `export const ${pascalName}Schema: z.ZodType<${pascalName}Base> = ${pascalName}SchemaBase`;
+    if (relatedTypes.length > 0) {
+      schemaString += `.extend({\n  ${relatedTypesLazy}});\n\n`;
+    } else {
+      schemaString += `;\n`;
+    }
+    schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
+
+    return schemaString;
+  };
+
+  typeToZod = (attribute: Attribute) => {
+    let baseSchemaCode = "";
+
+    switch (attribute.type) {
+      case "string":
+        baseSchemaCode = "z.string()";
+        if (attribute.size) {
+          baseSchemaCode += `.max(${attribute.size}, "Maximum length of ${attribute.size} characters exceeded")`;
+        }
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default("${attribute.xdefault}")`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "integer":
+        baseSchemaCode = "z.number().int()";
+        if (attribute.min !== undefined) {
+          baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+        }
+        if (attribute.max !== undefined) {
+          baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+        }
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default(${attribute.xdefault})`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "float":
+        baseSchemaCode = "z.number()";
+        if (attribute.min !== undefined) {
+          baseSchemaCode += `.min(${attribute.min}, "Minimum value of ${attribute.min} not met")`;
+        }
+        if (attribute.max !== undefined) {
+          baseSchemaCode += `.max(${attribute.max}, "Maximum value of ${attribute.max} exceeded")`;
+        }
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default(${attribute.xdefault})`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "boolean":
+        baseSchemaCode = "z.boolean()";
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default(${attribute.xdefault})`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "datetime":
+        baseSchemaCode = "z.date()";
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default(new Date("${attribute.xdefault}"))`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "email":
+        baseSchemaCode = "z.string().email()";
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default("${attribute.xdefault}")`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "ip":
+        baseSchemaCode = "z.string()"; // Add custom validation as needed
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default("${attribute.xdefault}")`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "url":
+        baseSchemaCode = "z.string().url()";
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default("${attribute.xdefault}")`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "enum":
+        baseSchemaCode = `z.enum([${attribute.elements
+          .map((element) => `"${element}"`)
+          .join(", ")}])`;
+        if (attribute.xdefault !== undefined) {
+          baseSchemaCode += `.default("${attribute.xdefault}")`;
+        }
+        if (!attribute.required && !attribute.array) {
+          baseSchemaCode += ".nullish()";
+        }
+        break;
+      case "relationship":
+        break;
+      default:
+        baseSchemaCode = "z.any()";
+    }
+
+    // Handle arrays
+    if (attribute.array) {
+      baseSchemaCode = `z.array(${baseSchemaCode})`;
+    }
+    if (attribute.array && !attribute.required) {
+      baseSchemaCode += ".nullish()";
+    }
+
+    return baseSchemaCode;
+  };
+}

package/src/migrations/setupDatabase.ts

@@ -0,0 +1,219 @@
+import { Databases, ID, Query, Storage, type Models } from "node-appwrite";
+import { createOrUpdateAttribute } from "./attributes.js";
+import {
+  createOrUpdateCollections,
+  generateSchemas,
+  wipeDatabase,
+} from "./collections.js";
+import { getMigrationCollectionSchemas } from "./backup.js";
+import { areCollectionNamesSame, toCamelCase } from "../utils/index.js";
+import {
+  backupDatabase,
+  initOrGetBackupStorage,
+  initOrGetDocumentStorage,
+  wipeDocumentStorage,
+} from "./storage.js";
+import { type AppwriteConfig } from "./schema.js";
+import type { SetupOptions } from "../utilsController.js";
+import { nameToIdMapping } from "./queue.js";
+import { UsersController } from "./users.js";
+
+export const setupMigrationDatabase = async (config: AppwriteConfig) => {
+  // Create the migrations database if needed
+  console.log("---------------------------------");
+  console.log("Starting Migrations Setup");
+  console.log("---------------------------------");
+  const database = new Databases(config.appwriteClient!);
+  let db: Models.Database | null = null;
+  const dbCollections: Models.Collection[] = [];
+  const migrationCollectionsSetup = getMigrationCollectionSchemas();
+  try {
+    db = await database.get("migrations");
+    console.log("Migrations database found");
+  } catch (e) {
+    db = await database.create("migrations", "Migrations", true);
+    console.log("Migrations database created");
+  }
+  if (db) {
+    const collectionsPulled = await database.listCollections(db.$id, [
+      Query.limit(25),
+    ]);
+    dbCollections.push(...collectionsPulled.collections);
+  }
+  console.log(`Collections in migrations database: ${dbCollections.length}`);
+
+  // Iterate over each key in the migrationCollectionsSetup object
+  for (const [collectionName, { collection, attributes }] of Object.entries(
+    migrationCollectionsSetup
+  )) {
+    const collectionId = toCamelCase(collectionName); // Convert name to toCamelCase for the ID
+    let collectionFound: Models.Collection | null = null;
+    try {
+      collectionFound = await database.getCollection(db.$id, collectionId);
+    } catch (e) {
+      console.log(`Collection not found: ${collectionId}`);
+    }
+    if (!collectionFound) {
+      // Create the collection with the provided configuration
+      collectionFound = await database.createCollection(
+        db.$id,
+        collectionId,
+        collectionName,
+        undefined,
+        collection.documentSecurity,
+        collection.enabled
+      );
+    }
+    for (const attribute of attributes) {
+      await createOrUpdateAttribute(
+        database,
+        db.$id,
+        collectionFound,
+        attribute
+      );
+    }
+  }
+  console.log("---------------------------------");
+  console.log("Migrations Setup Complete");
+  console.log("---------------------------------");
+};
+
+export const ensureDatabasesExist = async (config: AppwriteConfig) => {
+  const database = new Databases(config.appwriteClient);
+  const databasesToEnsure = config.databases;
+  databasesToEnsure.push({
+    $id: "migrations",
+    name: "Migrations",
+  });
+  const dbNames = databasesToEnsure.map((db) => db.name);
+
+  const existingDatabases = await database.list([Query.equal("name", dbNames)]);
+
+  for (const db of databasesToEnsure) {
+    if (!existingDatabases.databases.some((d) => d.name === db.name)) {
+      await database.create(db.$id || ID.unique(), db.name, true);
+      console.log(`${db.name} database created`);
+    }
+  }
+};
+
+export const wipeOtherDatabases = async (
+  database: Databases,
+  config: AppwriteConfig
+) => {
+  const databasesToKeep = config.databases.map((db) =>
+    db.name.toLowerCase().trim().replace(" ", "")
+  );
+  databasesToKeep.push("migrations");
+  console.log(`Databases to keep: ${databasesToKeep.join(", ")}`);
+  const allDatabases = await database.list([Query.limit(500)]);
+  for (const db of allDatabases.databases) {
+    if (
+      !databasesToKeep.includes(db.name.toLowerCase().trim().replace(" ", ""))
+    ) {
+      await database.delete(db.$id);
+      console.log(`Deleted database: ${db.name}`);
+    }
+  }
+};
+
+export const startSetup = async (
+  database: Databases,
+  storage: Storage,
+  config: AppwriteConfig,
+  setupOptions: SetupOptions,
+  appwriteFolderPath: string
+) => {
+  await setupMigrationDatabase(config);
+
+  if (config.enableBackups) {
+    await initOrGetBackupStorage(storage);
+    if (setupOptions.wipeDocumentStorage) {
+      if (setupOptions.runProd) {
+        await initOrGetDocumentStorage(
+          storage,
+          config,
+          config.databases[0].name
+        );
+        await wipeDocumentStorage(storage, config, config.databases[0].name);
+      }
+      if (setupOptions.runStaging) {
+        await initOrGetDocumentStorage(
+          storage,
+          config,
+          config.databases[1].name
+        );
+        await wipeDocumentStorage(storage, config, config.databases[1].name);
+      }
+      if (setupOptions.runDev) {
+        await initOrGetDocumentStorage(
+          storage,
+          config,
+          config.databases[2].name
+        );
+        await wipeDocumentStorage(storage, config, config.databases[2].name);
+      }
+    }
+  }
+  if (config.enableWipeOtherDatabases) {
+    await wipeOtherDatabases(database, config);
+  }
+  if (setupOptions.wipeUsers) {
+    const usersController = new UsersController(config, database);
+    console.log("Wiping users");
+    await usersController.wipeUsers();
+    console.log("Users wiped");
+  }
+  await ensureDatabasesExist(config);
+
+  const databaseNames = config.databases.map((db) => db.name);
+
+  // Move to here so it always runs if it's set to true
+  if (setupOptions.generateSchemas) {
+    await generateSchemas(config, appwriteFolderPath);
+  }
+
+  for (const db of config.databases) {
+    // Determine if the current database should be processed based on the setup options
+    const processDatabase =
+      (setupOptions.runProd &&
+        areCollectionNamesSame(db.name, databaseNames[0])) ||
+      (setupOptions.runStaging &&
+        areCollectionNamesSame(db.name, databaseNames[1])) ||
+      (setupOptions.runDev &&
+        areCollectionNamesSame(db.name, databaseNames[2]));
+    if (!processDatabase) {
+      continue;
+    } else {
+      await initOrGetDocumentStorage(storage, config, db.name);
+    }
+    console.log(`---------------------------------`);
+    console.log(`Starting setup for database: ${db.name}`);
+    console.log(`---------------------------------`);
+    let deletedCollections:
+      | { collectionId: string; collectionName: string }[]
+      | undefined;
+
+    if (setupOptions.wipeDatabases && processDatabase) {
+      if (config.enableBackups && setupOptions.doBackup) {
+        await backupDatabase(database, db.$id, storage);
+      }
+      deletedCollections = await wipeDatabase(database, db.$id);
+    }
+
+    if (processDatabase) {
+      await createOrUpdateCollections(
+        database,
+        db.$id,
+        config,
+        deletedCollections
+      );
+    }
+
+    deletedCollections = undefined;
+    nameToIdMapping.clear();
+    console.log(`---------------------------------`);
+    console.log(`Finished setup for database: ${db.name}`);
+    console.log(`---------------------------------`);
+  }
+};