appwrite-utils-cli 0.0.274 → 0.0.275

package/src/utils/setupFiles.ts

@@ -1,224 +1,63 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import configSchema from "./configSchema.json" assert { type: "json" };
+import type { AppwriteConfig } from "appwrite-utils";
+import { findAppwriteConfig } from "./loadConfigs.js";
+
+// Example base configuration using types from appwrite-utils
+const baseConfig: AppwriteConfig = {
+  appwriteEndpoint: "https://cloud.appwrite.io/v1",
+  appwriteProject: "YOUR_PROJECT_ID",
+  appwriteKey: "YOUR_API_KEY",
+  enableDevDatabase: true,
+  enableBackups: true,
+  backupInterval: 3600,
+  backupRetention: 30,
+  enableBackupCleanup: true,
+  enableMockData: false,
+  enableWipeOtherDatabases: true,
+  documentBucketId: "documents",
+  usersCollectionName: "Members",
+  databases: [
+    { $id: "main", name: "Main" },
+    { $id: "staging", name: "Staging" },
+    { $id: "dev", name: "Development" },
+  ],
+};
 
-// Define our YAML files
-// Define our YAML files
-const configFileExample = `# yaml-language-server: $schema=./.appwrite/appwriteUtilsConfigSchema.json
-# Appwrite configuration settings
-appwriteEndpoint: 'https://cloud.appwrite.io/v1' # Your Appwrite endpoint. Default: 'https://cloud.appwrite.io/v1'
-appwriteProject: 'YOUR_PROJECT_ID' # Your Appwrite project ID
-appwriteKey: 'YOUR_API_KEY' # Your Appwrite API key (needs storage and databases at minimum)
-appwriteClient: null # Your Appwrite client -- don't worry about this
-enableDevDatabase: true # Enable development database alongside main
-enableBackups: true # Enable backups
-backupInterval: 3600 # Backup interval in seconds
-backupRetention: 30 # Backup retention in days
-enableBackupCleanup: true # Enable backup cleanup
-enableMockData: false # Enable mock data generation
-enableWipeOtherDatabases: true # Enable wiping other databases
-documentBucketId: 'documents' # Your Appwrite bucket ID for documents
-usersCollectionName: 'Members' # Your Appwrite collection for any extra info while importing members (if any)
-                               # This allows you to use any targetKey in the users field to create your user
-                               # these are: name, email, phone, labels, prefs, password, userId and (not yet added)
-                               # $createdAt, $updatedAt -- Add them to your attributeMappings (NOT attributes) to define them and set the
-                               # targetKey to the same as the Appwrite targetKey
-databases:
-  - $id: 'main'
-    name: 'Main'
-  - $id: 'staging'
-    name: 'Staging'
-  - $id: 'dev'
-    name: 'Development'
-collections:
-  - name: 'Members'
-    $permissions:
-      - permission: read
-        target: any
-      - permission: create
-        target: users
-      - permission: update
-        target: users
-      - permission: delete
-        target: users
-    attributes:
-      - key: 'idOrig'
-        type: 'string'
-        size: 255
-        required: false
-      - key: 'dogs'
-        type: 'relationship'
-        relatedCollection: 'Dogs'
-        relationType: 'oneToMany'
-        twoWay: true
-        twoWayKey: 'owner'
-        side: 'parent'
-        onDelete: 'cascade'
-        importMapping: { originalIdField: 'idOrig', targetField: 'ownerIdOrig' }
-      - key: 'dogIds'
-        type: 'string'
-        size: 255
-        array: true
-      - key: 'profilePhoto'
-        type: 'string'
-        size: 255
-        required: false
-      - key: 'profilePhotoTest'
-        type: 'string'
-        size: 255
-        required: false
-    indexes:
-      - key: 'idOrig_index'
-        type: 'key'
-        attributes: ['idOrig']
-    importDefs:
-      - filePath: 'importData/members.json'
-        basePath: 'RECORDS'
-        attributeMappings:
-          - oldKey: 'id'
-            targetKey: 'idOrig'
-            converters: ['anyToString']
-            postImportActions:
-              - action: 'checkAndUpdateFieldInDocument'
-                params:
-                  - "{dbId}"
-                  - "{collId}"
-                  - "{docId}"
-                  - "idOrig"
-                  - "{id}"
-                  - "{$id}"
-          - oldKey: 'name'
-            targetKey: 'name'
-          - oldKey: 'email'
-            targetKey: 'email'
-          - oldKey: 'doesntMatter'
-            targetKey: 'profilePhoto'
-            fileData: { name: "profilePhoto_{id}", path: "importData/profilePhotos" }
-          - oldKey: 'photoUrl'
-            targetKey: 'profilePhotoTest'
-            fileData: { name: "profilePhotoTest_{id}", path: "{photoUrl}" }
-  - name: 'Dogs'
-    $permissions:
-      - permission: read
-        target: any
-      - permission: create
-        target: users
-      - permission: update
-        target: users
-      - permission: delete
-        target: users
-    attributes:
-      - key: 'name'
-        type: 'string'
-        size: 255
-        required: true
-      - key: 'breed'
-        type: 'string'
-        size: 255
-        required: false
-      - key: 'age'
-        type: 'integer'
-        required: false
-        min: 0
-        max: 100
-      - key: 'idOrig'
-        type: 'string'
-        size: 20
-        required: false
-      - key: 'ownerIdOrig'
-        type: 'string'
-        size: 255
-        required: false
-      - key: 'vetRecords'
-        type: 'string'
-        size: 255
-        required: false
-      - key: 'vetRecordIds'
-        type: 'string'
-        size: 255
-        array: true
-        required: false
-    indexes:
-      - key: 'ownerIdIndex'
-        type: 'key'
-        attributes: ['ownerIdOrig']
-    importDefs:
-      - filePath: 'importData/dogs.json'
-        basePath: 'RECORDS'
-        attributeMappings:
-          - oldKey: 'id'
-            targetKey: 'idOrig'
-          - oldKey: 'name'
-            targetKey: 'name'
-          - oldKey: 'breed'
-            targetKey: 'breed'
-          - oldKey: 'age'
-            targetKey: 'age'
-          - oldKey: 'ownerId'
-            targetKey: 'ownerIdOrig'
-          - oldKey: 'vetRecords'
-            targetKey: 'vetRecords'
-            converters: ['stringifyObject']
-          - oldKey: 'vetRecords.[any].id'
-            targetKey: 'vetRecordIds'
-            converters: ['anyToString']
-      - filePath: 'importData/dogs.json'
-        basePath: 'RECORDS'
-        type: 'update'
-        updateMapping: { originalIdField: 'id', targetField: 'idOrig' }
-        attributeMappings:
-          - oldKey: 'name'
-            targetKey: 'name'
-          - oldKey: 'breed'
-            targetKey: 'breed'
-          - oldKey: 'age'
-            targetKey: 'age'`;
+const collectionsConfig: { name: string; content: string }[] = [
+  {
+    name: "ExampleCollection",
+    content: `import { CollectionCreate } from "appwrite-utils";
+    
+const ExampleCollection: Partial<CollectionCreate> = {
+  name: 'ExampleCollection',
+  $permissions: [
+    { permission: 'read', target: 'any' },
+    { permission: 'create', target: 'users' },
+    { permission: 'update', target: 'users' },
+    { permission: 'delete', target: 'users' }
+  ],
+  attributes: [
+    { key: 'alterEgoName', type: 'string', size: 255, required: false },
+    // Add more attributes here
+  ],
+  indexes: [
+    { key: 'alterEgoName_search', type: 'fulltext', attributes: ['alterEgoName'] }
+  ],
+  importDefs: [
+    // Define import definitions here
+  ]
+};
 
-const configFile = `# yaml-language-server: $schema=./.appwrite/appwriteUtilsConfigSchema.json
-# Basic Appwrite configuration settings
-appwriteEndpoint: 'https://cloud.appwrite.io/v1' # Your Appwrite endpoint
-appwriteProject: 'YOUR_PROJECT_ID' # Your Appwrite project ID
-appwriteKey: 'YOUR_API_KEY' # Your Appwrite API key (needs storage and databases at minimum)
-enableDevDatabase: true # Enable development database alongside main. Default: true
-enableBackups: true # Enable backups. Default: true
-backupInterval: 3600 # Backup interval in seconds. Default: 3600 - DOES NOTHING RIGHT NOW
-backupRetention: 30 # Backup retention in days. Default: 30 - DOES NOTHING RIGHT NOW
-enableBackupCleanup: true # Enable backup cleanup. Default: true - DOES NOTHING RIGHT NOW
-enableMockData: false # Enable mock data generation. Default: false - DOES NOTHING RIGHT NOW
-enableWipeOtherDatabases: true # Enable wiping other databases. Default: true
-documentBucketId: 'documents' # Your Appwrite bucket ID for documents. Default: 'documents'
-usersCollectionName: 'Members' # Your Appwrite collection for any extra info while importing members (if any). Default: 'Members'
-# Databases configuration
-# The first one is *always* Production
-# The second is *always* Staging
-# The third is *always* Development
-# They are found by name matching (without spaces and all lowercase), not $id
-# If no $id is included for anything defined, Appwrite will auto-generate one in its stead
-databases:
-  - $id: 'main' # Database ID
-    name: 'Main' # Database name
-  - $id: 'staging'
-    name: 'Staging'
-  - $id: 'dev'
-    name: 'Development'
+export default ExampleCollection;`,
+  },
+  // Add more collections here
+];
 
-# Collections configuration
-collections:
-  - name: 'ExampleCollection' # Collection name
-    $permissions: # Permissions for the collection
-      - permission: read # Permission type
-        target: any # Permission target
-      - permission: create
-        target: users
-      - permission: update
-        target: users
-      - permission: delete
-        target: users
-    attributes: # Attributes of the collection
-      - key: 'exampleKey' # Attribute key
-        type: 'string' # Attribute type
-        size: 255 # Size of the attribute (for strings)
-        required: true # Whether the attribute is required`;
+// Define our YAML files
+// Define our YAML files
+const configFileExample = `d`;
 
 export const customDefinitionsFile = `import type { ConverterFunctions, ValidationRules, AfterImportActions } from "appwrite-utils";
 
@@ -232,9 +71,47 @@ export const customAfterImportActions: AfterImportActions = {
   // Add your custom after import actions here
 }`;
 
+export const createEmptyCollection = (collectionName: string) => {
+  const emptyCollection = `import type { CollectionCreate } from "appwrite-utils";
+
+const ${collectionName}: Partial<CollectionCreate> = {
+  name: '${collectionName}',
+  $permissions: [
+    { permission: 'read', target: 'any' },
+    { permission: 'create', target: 'users' },
+    { permission: 'update', target: 'users' },
+    { permission: 'delete', target: 'users' }
+  ],
+  attributes: [
+    // Add more attributes here
+  ],
+  indexes: [
+    // Add more indexes here
+  ],
+};
+
+export default ${collectionName};`;
+
+  const appwriteConfigPath = findAppwriteConfig(process.cwd());
+  if (!appwriteConfigPath) {
+    console.error("Failed to find appwriteConfig.ts");
+    return;
+  }
+
+  const collectionsFolder = path.join(
+    path.dirname(appwriteConfigPath),
+    "collections"
+  );
+  const collectionFilePath = path.join(
+    collectionsFolder,
+    `${collectionName}.ts`
+  );
+  writeFileSync(collectionFilePath, emptyCollection);
+};
+
 export const setupDirsFiles = async (example: boolean = false) => {
   const basePath = process.cwd();
-  const srcPath = path.join(basePath, "src");
+  const srcPath = path.join(basePath);
 
   // Check if src directory exists in the current working directory
   if (!existsSync(srcPath)) {
@@ -243,7 +120,7 @@ export const setupDirsFiles = async (example: boolean = false) => {
   }
 
   const appwriteFolder = path.join(srcPath, "appwrite");
-  const appwriteConfigFile = path.join(appwriteFolder, "appwriteConfig.yaml");
+  const appwriteConfigFile = path.join(appwriteFolder, "appwriteConfig.ts");
   const appwriteCustomDefsFile = path.join(
     appwriteFolder,
     "customDefinitions.ts"
@@ -252,27 +129,39 @@ export const setupDirsFiles = async (example: boolean = false) => {
   const appwriteSchemaFolder = path.join(appwriteFolder, "schemas");
   const appwriteDataFolder = path.join(appwriteFolder, "importData");
   const appwriteHiddenFolder = path.join(appwriteFolder, ".appwrite");
+  const collectionsFolder = path.join(appwriteFolder, "collections");
 
   // Directory creation and file writing logic remains the same
   if (!existsSync(appwriteFolder)) {
     mkdirSync(appwriteFolder, { recursive: true });
   }
 
+  if (!existsSync(collectionsFolder)) {
+    mkdirSync(collectionsFolder, { recursive: true });
+  }
+
   if (!existsSync(appwriteConfigFile)) {
     if (example) {
       writeFileSync(appwriteConfigFile, configFileExample);
     } else {
-      writeFileSync(appwriteConfigFile, configFile);
+      const baseConfigContent = `import { AppwriteConfig } from "appwrite-utils";
+
+const appwriteConfig: AppwriteConfig = ${JSON.stringify(baseConfig, null, 2)};
+
+export default appwriteConfig;
+`;
+      writeFileSync(appwriteConfigFile, baseConfigContent);
     }
   }
 
-  // if (!existsSync(appwriteCustomDefsFile)) {
-  //   writeFileSync(appwriteCustomDefsFile, customDefinitionsFile);
-  // }
-
-  // if (!existsSync(appwriteMigrationsFolder)) {
-  //   mkdirSync(appwriteMigrationsFolder, { recursive: true });
-  // }
+  // Create TypeScript files for each collection
+  collectionsConfig.forEach((collection) => {
+    const collectionFilePath = path.join(
+      collectionsFolder,
+      `${collection.name}.ts`
+    );
+    writeFileSync(collectionFilePath, collection.content);
+  });
 
   if (!existsSync(appwriteSchemaFolder)) {
     mkdirSync(appwriteSchemaFolder, { recursive: true });

package/src/utilsController.ts

@@ -1,39 +1,35 @@
 import { Client, Databases, Storage } from "node-appwrite";
 import { startSetup } from "./migrations/setupDatabase.js";
-import {
-  type AppwriteConfig,
-  AppwriteConfigSchema,
-} from "./migrations/schema.js";
 import path from "path";
 import fs from "fs";
 import { load } from "js-yaml";
 import { ImportDataActions } from "./migrations/importDataActions.js";
-import {
-  converterFunctions,
-  type ConverterFunctions,
-} from "./migrations/converters.js";
 import { readFileSync } from "./utils/helperFunctions.js";
+import { afterImportActions } from "./migrations/afterImportActions.js";
 import {
-  afterImportActions,
   type AfterImportActions,
-} from "./migrations/afterImportActions.js";
-import {
+  type ConverterFunctions,
+  converterFunctions,
   validationRules,
   type ValidationRules,
-} from "./migrations/validationRules.js";
+  type AppwriteConfig,
+  AppwriteConfigSchema,
+} from "appwrite-utils";
 import { ImportController } from "./migrations/importController.js";
 import _ from "lodash";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
+import { loadConfig as loadTsConfig } from "./utils/loadConfigs.js";
+import { findAppwriteConfig } from "./utils/loadConfigs.js";
 
-async function loadConfig(configPath: string) {
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`Configuration file not found at ${configPath}`);
-  }
-  const configModule = await load(readFileSync(configPath), {
-    json: true,
-  });
-  return AppwriteConfigSchema.parse(configModule);
-}
+// async function loadConfig(configPath: string) {
+//   if (!fs.existsSync(configPath)) {
+//     throw new Error(`Configuration file not found at ${configPath}`);
+//   }
+//   const configModule = await load(readFileSync(configPath), {
+//     json: true,
+//   });
+//   return AppwriteConfigSchema.parse(configModule);
+// }
 
 export interface SetupOptions {
   sync: boolean;
@@ -54,12 +50,6 @@ export interface SetupOptions {
   key?: string;
 }
 
-type CollectionConfig = AppwriteConfig["collections"];
-type ImportDef = CollectionConfig[number]["importDefs"][number];
-type AttributeMappings = ImportDef["attributeMappings"];
-type AfterImportAction = AttributeMappings[number]["postImportActions"][number];
-type ValidityRule = AttributeMappings[number]["validationActions"][number];
-
 export class UtilsController {
   private appwriteFolderPath: string;
   private appwriteConfigPath: string;
@@ -73,13 +63,12 @@ export class UtilsController {
 
   constructor() {
     const basePath = process.cwd(); // Gets the current working directory
-    const appwriteFolderPath = path.join(basePath, "src", "appwrite");
-    const appwriteConfigPath = path.join(
-      appwriteFolderPath,
-      "appwriteConfig.yaml"
-    );
-    this.appwriteFolderPath = appwriteFolderPath;
-    this.appwriteConfigPath = appwriteConfigPath;
+    const appwriteConfigFound = findAppwriteConfig(basePath);
+    if (!appwriteConfigFound) {
+      throw new Error("Failed to find appwriteConfig.ts");
+    }
+    this.appwriteConfigPath = appwriteConfigFound;
+    this.appwriteFolderPath = path.dirname(appwriteConfigFound);
   }
 
   // async loadCustomDefinitions(): Promise<void> {
@@ -114,7 +103,10 @@ export class UtilsController {
   async init(setupOptions: SetupOptions) {
     if (!this.config) {
       console.log("Initializing appwrite client & loading config...");
-      this.config = await loadConfig(this.appwriteConfigPath);
+      this.config = await loadTsConfig(this.appwriteFolderPath);
+      if (!this.config) {
+        throw new Error("Failed to load config");
+      }
       this.appwriteServer = new Client();
       if (setupOptions.endpoint) {
         if (!setupOptions.project || !setupOptions.key) {