appwrite-utils-cli 0.0.274 → 0.0.275

package/src/migrations/importDataActions.ts

@@ -5,22 +5,18 @@ import {
   type Databases,
   type Storage,
 } from "node-appwrite";
-import type { AppwriteConfig } from "./schema.js";
-import { validationRules, type ValidationRules } from "./validationRules.js";
+import type { AppwriteConfig } from "appwrite-utils";
 import {
-  converterFunctions,
-  convertObjectBySchema,
-  type ConverterFunctions,
-} from "./converters.js";
-import {
-  afterImportActions,
-  type AfterImportActions,
-} from "./afterImportActions.js";
+  validationRules,
+  type ValidationRules,
+  type AttributeMappings,
+} from "appwrite-utils";
+import { converterFunctions, type ConverterFunctions } from "appwrite-utils";
+import { convertObjectBySchema } from "./converters.js";
+import { type AfterImportActions } from "appwrite-utils";
+import { afterImportActions } from "./afterImportActions.js";
 import { logger } from "./logging.js";
 
-type AttributeMappings =
-  AppwriteConfig["collections"][number]["importDefs"][number]["attributeMappings"];
-
 export class ImportDataActions {
   private db: Databases;
   private storage: Storage;
@@ -48,7 +44,7 @@ export class ImportDataActions {
   runConverterFunctions(item: any, attributeMappings: AttributeMappings) {
     const conversionSchema = attributeMappings.reduce((schema, mapping) => {
       schema[mapping.targetKey] = (originalValue: any) => {
-        return mapping.converters.reduce((value, converterName) => {
+        return mapping.converters?.reduce((value, converterName) => {
           let shouldProcessAsArray = false;
           if (
             (converterName.includes("[Arr]") ||

package/src/migrations/indexes.ts

@@ -1,4 +1,4 @@
-import { indexSchema, type Index } from "./schema.js";
+import { indexSchema, type Index } from "appwrite-utils";
 import { Databases, Query, type Models } from "node-appwrite";
 // import {}
 

package/src/migrations/migrationHelper.ts

@@ -1,6 +1,6 @@
 import { ID, Query, type Databases } from "node-appwrite";
 import { BatchSchema, OperationSchema, type Operation } from "./backup.js";
-import { type AttributeMappings, AttributeMappingsSchema } from "./schema.js";
+import { AttributeMappingsSchema } from "appwrite-utils";
 import { z } from "zod";
 import { logger } from "./logging.js";
 

package/src/migrations/openapi.ts

@@ -10,13 +10,16 @@ import {
   type Attribute,
   type Collection,
   type CollectionCreate,
-} from "./schema.js";
+} from "appwrite-utils";
 import { z } from "zod";
 import { writeFileSync } from "fs";
 
 const registry = new OpenAPIRegistry();
 
 export const generateOpenApi = async (config: AppwriteConfig) => {
+  if (!config.collections) {
+    return;
+  }
   for (const collection of config.collections) {
     // Transform and register each attribute schema
     const attributeSchemas = collection.attributes.map((attribute) => {

package/src/migrations/queue.ts

@@ -1,5 +1,5 @@
 import { Query, type Databases, type Models } from "node-appwrite";
-import type { Attribute } from "./schema.js";
+import type { Attribute } from "appwrite-utils";
 import { createOrUpdateAttribute } from "./attributes.js";
 import _ from "lodash";
 import { fetchAndCacheCollectionByName } from "./collections.js";

package/src/migrations/relationships.ts

@@ -4,7 +4,7 @@ import type {
   AppwriteConfig,
   Attribute,
   RelationshipAttribute,
-} from "./schema.js";
+} from "appwrite-utils";
 import { logger } from "./logging.js";
 
 /**
@@ -12,6 +12,9 @@ import { logger } from "./logging.js";
  */
 export const findCollectionsWithRelationships = (config: AppwriteConfig) => {
   const toReturn = new Map<string, RelationshipAttribute[]>();
+  if (!config.collections) {
+    return toReturn;
+  }
   for (const collection of config.collections) {
     if (collection.attributes) {
       for (const attribute of collection.attributes) {

package/src/migrations/schemaStrings.ts

@@ -3,7 +3,7 @@ import type {
   AppwriteConfig,
   Attribute,
   RelationshipAttribute,
-} from "./schema.js";
+} from "appwrite-utils";
 import { z } from "zod";
 import fs from "fs";
 import path from "path";
@@ -30,17 +30,111 @@ 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}`);
+  public updateTsSchemas(): void {
+    const collections = this.config.collections;
+    delete this.config.collections;
+
+    const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
+    const configContent = `import { AppwriteConfig } from "appwrite-utils";
+  
+  const appwriteConfig: AppwriteConfig = {
+    appwriteEndpoint: "${this.config.appwriteEndpoint}",
+    appwriteProject: "${this.config.appwriteProject}",
+    appwriteKey: "${this.config.appwriteKey}",
+    enableDevDatabase: ${this.config.enableDevDatabase},
+    enableBackups: ${this.config.enableBackups},
+    backupInterval: ${this.config.backupInterval},
+    backupRetention: ${this.config.backupRetention},
+    enableBackupCleanup: ${this.config.enableBackupCleanup},
+    enableMockData: ${this.config.enableMockData},
+    enableWipeOtherDatabases: ${this.config.enableWipeOtherDatabases},
+    documentBucketId: "${this.config.documentBucketId}",
+    usersCollectionName: "${this.config.usersCollectionName}",
+    databases: ${JSON.stringify(this.config.databases)}
+  };
+  
+  export default appwriteConfig;
+  `;
+    fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
+
+    const collectionsFolderPath = path.join(
+      this.appwriteFolderPath,
+      "collections"
+    );
+    if (!fs.existsSync(collectionsFolderPath)) {
+      fs.mkdirSync(collectionsFolderPath, { recursive: true });
+    }
+
+    collections?.forEach((collection) => {
+      const { databaseId, ...collectionWithoutDbId } = collection; // Destructure to exclude databaseId
+      const collectionFilePath = path.join(
+        collectionsFolderPath,
+        `${collection.name}.ts`
+      );
+      const collectionContent = `import { CollectionCreate } from "appwrite-utils";
+  
+  const ${collection.name}Config: Partial<CollectionCreate> = {
+    name: "${collection.name}",
+    $id: "${collection.$id}",
+    enabled: ${collection.enabled},
+    documentSecurity: ${collection.documentSecurity},
+    $permissions: [
+      ${collection.$permissions
+        .map(
+          (permission) =>
+            `{ permission: "${permission.permission}", target: "${permission.target}" }`
+        )
+        .join(",\n    ")}
+    ],
+    attributes: [
+      ${collection.attributes
+        .map((attr) => {
+          return `{ ${Object.entries(attr)
+            .map(([key, value]) => {
+              // Check the type of the value and format it accordingly
+              if (typeof value === "string") {
+                // If the value is a string, wrap it in quotes
+                return `${key}: "${value.replace(/"/g, '\\"')}"`; // Escape existing quotes in the string
+              } else if (Array.isArray(value)) {
+                // If the value is an array, join it with commas
+                return `${key}: [${value
+                  .map((item) => `"${item}"`)
+                  .join(", ")}]`;
+              } else {
+                // If the value is not a string (e.g., boolean or number), output it directly
+                return `${key}: ${value}`;
+              }
+            })
+            .join(", ")} }`;
+        })
+        .join(",\n    ")}
+    ],
+    indexes: [
+      ${(
+        collection.indexes?.map((index) => {
+          // Map each attribute to ensure it is properly quoted
+          const formattedAttributes = index.attributes
+            .map((attr) => `"${attr}"`)
+            .join(", ");
+          return `{ key: "${index.key}", type: "${index.type}", attributes: [${formattedAttributes}] }`;
+        }) ?? []
+      ).join(",\n    ")}
+    ]
+  };
+  
+  export default ${collection.name}Config;
+  `;
+      fs.writeFileSync(collectionFilePath, collectionContent, {
+        encoding: "utf-8",
+      });
+      console.log(`Collection schema written to ${collectionFilePath}`);
+    });
   }
 
   private extractRelationships(): void {
+    if (!this.config.collections) {
+      return;
+    }
     this.config.collections.forEach((collection) => {
       collection.attributes.forEach((attr) => {
         if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
@@ -115,6 +209,9 @@ export class SchemaGenerator {
   }
 
   public generateSchemas(): void {
+    if (!this.config.collections) {
+      return;
+    }
     this.config.collections.forEach((collection) => {
       const schemaString = this.createSchemaString(
         collection.name,

package/src/migrations/setupDatabase.ts

@@ -13,7 +13,7 @@ import {
   initOrGetDocumentStorage,
   wipeDocumentStorage,
 } from "./storage.js";
-import { type AppwriteConfig } from "./schema.js";
+import { type AppwriteConfig } from "appwrite-utils";
 import type { SetupOptions } from "../utilsController.js";
 import { nameToIdMapping } from "./queue.js";
 import { UsersController } from "./users.js";

package/src/migrations/storage.ts

@@ -9,7 +9,7 @@ import {
 } from "node-appwrite";
 import { type OperationCreate, type BackupCreate } from "./backup.js";
 import { splitIntoBatches } from "./migrationHelper.js";
-import type { AppwriteConfig } from "./schema.js";
+import type { AppwriteConfig } from "appwrite-utils";
 
 export const logOperation = async (
   db: Databases,

package/src/migrations/users.ts

@@ -1,4 +1,4 @@
-import type { AppwriteConfig, ConfigCollection } from "./schema.js";
+import type { AppwriteConfig, ConfigCollection } from "appwrite-utils";
 import { Databases, ID, Query, Users, type Models } from "node-appwrite";
 import {
   AuthUserSchema,

package/src/types.ts

@@ -1,14 +1,9 @@
-export type { AppwriteConfig } from "./migrations/schema.js";
-export type { ConverterFunctions } from "./migrations/converters.js";
 export type { ValidationRules } from "./migrations/validationRules.js";
-export type { AfterImportActions } from "./migrations/afterImportActions.js";
 export {
   type AuthUserCreate,
   AuthUserCreateSchema,
   type AuthUser,
   AuthUserSchema,
 } from "./schemas/authUser.js";
-export { getFileViewUrl, getFileDownloadUrl } from "./utils/helperFunctions.js";
-export { converterFunctions } from "./migrations/converters.js";
 export { validationRules } from "./migrations/validationRules.js";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/src/utils/helperFunctions.ts

@@ -1,9 +1,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";
+import type { CollectionImportData } from "../migrations/dataLoader.js";
+import type { ConfigCollection } from "appwrite-utils";
 
 export const toPascalCase = (str: string): string => {
   return (

package/src/utils/loadConfigs.ts

@@ -0,0 +1,55 @@
+import path from "path";
+import fs from "fs";
+import { type AppwriteConfig, type Collection } from "appwrite-utils";
+import { register } from "tsx/esm/api"; // Import the register function
+
+/**
+ * Recursively searches for a file named 'appwriteConfig.ts' starting from the given directory.
+ * @param dir The directory to start the search from.
+ * @returns The path to the file if found, or null if not found.
+ */
+export const findAppwriteConfig = (dir: string): string | null => {
+  const files = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const file of files) {
+    if (file.isDirectory()) {
+      const result = findAppwriteConfig(path.join(dir, file.name));
+      if (result) return result;
+    } else if (file.name === "appwriteConfig.ts") {
+      return path.join(dir, file.name);
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Loads the Appwrite configuration and all collection configurations from a specified directory.
+ * @param configDir The directory containing the appwriteConfig.ts and collections folder.
+ * @returns The loaded Appwrite configuration including collections.
+ */
+export const loadConfig = async (
+  configDir: string
+): Promise<AppwriteConfig> => {
+  const unregister = register(); // Register tsx enhancement
+
+  try {
+    const configPath = path.resolve(configDir, "appwriteConfig.ts");
+    const config = (await import(configPath)).default as AppwriteConfig;
+
+    const collectionsDir = path.resolve(configDir, "collections");
+    const collectionFiles = fs.readdirSync(collectionsDir);
+
+    config.collections = [];
+
+    for (const file of collectionFiles) {
+      const filePath = path.resolve(collectionsDir, file);
+      const collectionModule = (await import(filePath)).default as Collection;
+      config.collections.push(collectionModule);
+    }
+
+    return config;
+  } finally {
+    unregister(); // Unregister tsx when done
+  }
+};