appwrite-utils-cli 0.0.273 → 0.0.275

package/dist/utils/loadConfigs.js

@@ -0,0 +1,47 @@
+import path from "path";
+import fs from "fs";
+import {} 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) => {
+    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) => {
+    const unregister = register(); // Register tsx enhancement
+    try {
+        const configPath = path.resolve(configDir, "appwriteConfig.ts");
+        const config = (await import(configPath)).default;
+        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;
+            config.collections.push(collectionModule);
+        }
+        return config;
+    }
+    finally {
+        unregister(); // Unregister tsx when done
+    }
+};

package/dist/utils/setupFiles.d.ts

@@ -1,2 +1,3 @@
 export declare const customDefinitionsFile = "import type { ConverterFunctions, ValidationRules, AfterImportActions } from \"appwrite-utils\";\n\nexport const customConverterFunctions: ConverterFunctions = {\n  // Add your custom converter functions here\n}\nexport const customValidationRules: ValidationRules = {\n  // Add your custom validation rules here\n}\nexport const customAfterImportActions: AfterImportActions = {\n  // Add your custom after import actions here\n}";
+export declare const createEmptyCollection: (collectionName: string) => void;
 export declare const setupDirsFiles: (example?: boolean) => Promise<void>;

package/dist/utils/setupFiles.js

@@ -1,222 +1,59 @@
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
 import path from "node:path";
 import configSchema from "./configSchema.json" assert { type: "json" };
+import { findAppwriteConfig } from "./loadConfigs.js";
+// Example base configuration using types from appwrite-utils
+const baseConfig = {
+    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" },
+    ],
+};
+const collectionsConfig = [
+    {
+        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
+  ]
+};
+
+export default ExampleCollection;`,
+    },
+    // Add more collections here
+];
 // 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 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'
-
-# 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`;
+const configFileExample = `d`;
 export const customDefinitionsFile = `import type { ConverterFunctions, ValidationRules, AfterImportActions } from "appwrite-utils";
 
 export const customConverterFunctions: ConverterFunctions = {
@@ -228,39 +65,77 @@ export const customValidationRules: ValidationRules = {
 export const customAfterImportActions: AfterImportActions = {
   // Add your custom after import actions here
 }`;
+export const createEmptyCollection = (collectionName) => {
+    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 = 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)) {
         console.error("No 'src' directory found in the current working directory.");
         return;
     }
     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");
     // const appwriteMigrationsFolder = path.join(appwriteFolder, "migrations");
     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/dist/utilsController.d.ts

@@ -1,6 +1,4 @@
-import { type ConverterFunctions } from "./migrations/converters.js";
-import { type AfterImportActions } from "./migrations/afterImportActions.js";
-import { type ValidationRules } from "./migrations/validationRules.js";
+import { type AfterImportActions, type ConverterFunctions, type ValidationRules } from "appwrite-utils";
 export interface SetupOptions {
     sync: boolean;
     runProd: boolean;

package/dist/utilsController.js

@@ -1,26 +1,17 @@
 import { Client, Databases, Storage } from "node-appwrite";
 import { startSetup } from "./migrations/setupDatabase.js";
-import { 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, } from "./migrations/converters.js";
 import { readFileSync } from "./utils/helperFunctions.js";
-import { afterImportActions, } from "./migrations/afterImportActions.js";
-import { validationRules, } from "./migrations/validationRules.js";
+import { afterImportActions } from "./migrations/afterImportActions.js";
+import { converterFunctions, validationRules, AppwriteConfigSchema, } from "appwrite-utils";
 import { ImportController } from "./migrations/importController.js";
 import _ from "lodash";
 import { AppwriteToX } from "./migrations/appwriteToX.js";
-async function loadConfig(configPath) {
-    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);
-}
+import { loadConfig as loadTsConfig } from "./utils/loadConfigs.js";
+import { findAppwriteConfig } from "./utils/loadConfigs.js";
 export class UtilsController {
     appwriteFolderPath;
     appwriteConfigPath;
@@ -33,10 +24,12 @@ export class UtilsController {
     afterImportActionsDefinitions = afterImportActions;
     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> {
     //   try {
@@ -69,7 +62,10 @@ export class UtilsController {
     async init(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) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "appwrite-utils-cli",
   "description": "Appwrite Utility Functions to help with database management, data conversion, data import, migrations, and much more. Meant to be used as a CLI tool, I do not recommend installing this in frontend environments.",
-  "version": "0.0.273",
+  "version": "0.0.275",
   "main": "src/main.ts",
   "type": "module",
   "repository": {
@@ -21,21 +21,28 @@
     "utility"
   ],
   "bin": {
-    "appwrite-setup": "./dist/setup.js",
+    "appwrite-init": "./dist/init.js",
     "appwrite-migrate": "./dist/main.js"
   },
   "scripts": {
     "build": "bun run tsc",
+    "init": "tsx --no-cache src/init.ts",
+    "migrate": "tsx --no-cache src/main.ts",
     "deploy": "bun run build && npm publish --access public",
     "postinstall": "echo 'This package is intended for CLI use only and should not be added as a dependency in other projects.'"
   },
   "dependencies": {
     "@asteasolutions/zod-to-openapi": "^7.0.0",
+    "@types/inquirer": "^9.0.7",
+    "appwrite-utils": "workspace:*",
+    "commander": "^12.0.0",
+    "inquirer": "^9.2.20",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "luxon": "^3.4.4",
     "nanostores": "^0.10.3",
     "node-appwrite": "^12.0.1",
+    "tsx": "^4.9.3",
     "winston": "^3.13.0",
     "zod": "^3.22.4"
   },

package/src/init.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import inquirer from "inquirer";
+import { createEmptyCollection, setupDirsFiles } from "./utils/setupFiles.js";
+
+console.log("Welcome to Appwrite Utils CLI Tool by Zach Handley");
+console.log(
+  "For more information, visit https://github.com/zachhandley/appwrite-utils"
+);
+
+async function main() {
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "What would you like to do?",
+      choices: [
+        "Create collection config file",
+        "Create function (not available)",
+        "Setup directories and files",
+        "Setup directories and files with example data",
+        "Exit",
+      ],
+    },
+  ]);
+
+  switch (answers.action) {
+    case "Create collection config file":
+      const { collectionName } = await inquirer.prompt([
+        {
+          type: "input",
+          name: "collectionName",
+          message: "Enter the name of the collection:",
+          validate: (input) =>
+            input.trim() !== "" || "Collection name cannot be empty.",
+        },
+      ]);
+      console.log(`Creating collection config file for '${collectionName}'...`);
+      createEmptyCollection(collectionName);
+      break;
+    case "Create function (not available)":
+      console.log("This feature is not available yet.");
+      break;
+    case "Setup directories and files":
+      console.log("Setting up directories and files...");
+      setupDirsFiles(false); // Assuming false means no example data
+      break;
+    case "Setup directories and files with example data":
+      console.log("Setting up directories and files with example data...");
+      setupDirsFiles(true); // Assuming false means no example data
+      break;
+    case "Exit":
+      console.log("Exiting...");
+      process.exit(0);
+      break;
+    default:
+      console.log("Invalid option, please try again.");
+      break;
+  }
+}
+
+main().catch((error) => {
+  console.error("An error occurred:", error);
+  process.exit(1);
+});