appwrite-utils-cli 0.0.273 → 0.0.275

package/README.md

@@ -6,7 +6,7 @@
 
 ## Features
 
-- **Easy Configuration**: Initialize your Appwrite project configurations and setup directly from the command line.
+- **Easy Configuration**: Initialize your Appwrite project configurations interactively directly from the command line.
 - **Database Migrations**: Control the migration process with options to target production, staging, or development environments.
 - **Schema Generation**: Generate and manage TypeScript schemas directly from your Appwrite database schemas.
 - **Data Import**: Facilitate the import of data into your Appwrite databases with comprehensive command-line support.
@@ -35,26 +35,12 @@ After installation, you can access the tool directly from your command line usin
 
 ### Initialization
 
-Set up your Appwrite project with necessary configurations:
+Interactively set up your Appwrite project with necessary configurations:
 
 ```bash
-npx --package=appwrite-utils-cli@latest appwrite-setup
+npx --package=appwrite-utils-cli@latest appwrite-init
 ```
 
-To generate an example configuration file:
-
-```bash
-appwrite-setup --example
-```
-
-To synchronize your `appwriteConfig.yaml` with your Appwrite Database, first you must run the setup command and enter your Appwrite instances details in the `projectId`, `endpoint`, and `apiKey`, then run the following
-
-```bash
-npx --package=appwrite-utils-cli@latest appwrite-migrate -- --sync
-```
-
-This will initialize your config and generate schemas for your database using ZOD to `src/appwrite/schemas`
-
 ### Running Migrations and Tasks
 
 Run migration and management tasks with specific flags according to your needs:
@@ -80,28 +66,6 @@ Replace `--args` with the appropriate options:
 - `--project`: Set a different project ID for the migration target
 - `--key`: Set a different API key for the migration target
 
-For example, to run migrations in a development environment and import data:
-
-```bash
-npx --package=appwrite-utils-cli@latest appwrite-migrate --dev --import
-```
-
-To initialize your project, generate schemas, but not import data:
-
-```bash
-npx --package=appwrite-utils-cli@latest appwrite-migrate --init
-```
-
-To sync:
-
-```bash
-# If you have no appwriteConfig
-npx --package=appwrite-utils-cli@latest appwrite-migrate --init
-
-# Otherwise, you can remove everything in the config file down to the word collections, just leave your Databases, then run
-npx --package=appwrite-utils-cli@latest appwrite-migrate --sync
-```
-
 ### OpenAPI Generation (almost done, in progress)
 
 Recently, I have also added an optional OpenAPI generation for each attribute in the schema. This is because I needed it and because I felt it would be nice to have. This is done using [this package](https://github.com/asteasolutions/zod-to-openapi), many thanks to them.
@@ -118,6 +82,8 @@ This setup ensures that developers have robust tools at their fingertips to mana
 
 ### Changelog
 
+- 0.0.275: THINGS ARE NOW IN TYPESCRIPT WOOHOO. No but for reaal, super happy to report that everything has been converted to TypeScript, just way too many changes, I hope you enjoy it!
+- 0.0.274: Small improvement for attribute handling, rather than getting it every attribute, I check the collections attributes
 - 0.0.273: Small fix for relationship attribute comparisons
 - 0.0.272: That's what I get for not testing lmao, also updated logic for checking for existing attributes to take the `format` into consideration from the database (URL's are not of `type: "url"`, they are of `format: "url"`)
 - 0.0.271: Small change to update attributes that are different from each other by deleting the attribute and recreating, as we cannot update most things

package/dist/init.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/init.js

@@ -0,0 +1,57 @@
+#!/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);
+});

package/dist/main.js

@@ -1,103 +1,65 @@
 #!/usr/bin/env node
+import { program } from "commander";
 import { UtilsController } from "./utilsController.js";
-const args = process.argv.slice(2);
-async function main() {
+// Setup the main CLI program
+program
+    .version("1.0.0")
+    .description("Utility CLI for Appwrite configurations and operations")
+    .option("--endpoint <endpoint>", "Set the Appwrite endpoint", undefined)
+    .option("--project <project>", "Set the Appwrite project ID", undefined)
+    .option("--key <key>", "Set the Appwrite API key", undefined)
+    .option("--backup", "Perform a backup before executing the command", false)
+    .option("--dev", "Run in development environment", false)
+    .option("--prod", "Run in production environment", false)
+    .option("--staging", "Run in staging environment", false)
+    .option("--sync", "Synchronize configurations", false)
+    .option("--wipe", "Wipe databases", false)
+    .option("--wipe-docs", "Wipe documents", false)
+    .option("--wipe-users", "Wipe users", false)
+    .option("--generate", "Generate schemas", false)
+    .option("--import", "Import data", false)
+    .option("--write-data", "Write data to file", false)
+    .option("-h, --help", "Display help for command", false);
+program.on("--help", () => {
+    console.log("");
+    console.log("Examples:");
+    console.log("  $ npx appwrite-utils-cli appwrite-migrate --sync --endpoint https://appwrite.example.com --project 123456 --key 7890");
+    console.log("  $ npx appwrite-utils-cli appwrite-migrate --sync --dev --backup");
+    console.log("  $ npx appwrite-utils-cli appwrite-migrate --wipe --wipe-docs --wipe-users --dev");
+    console.log("  $ npx appwrite-utils-cli appwrite-migrate --generate --import --write-data --dev");
+    console.log("  $ npx appwrite-utils-cli appwrite-migrate --sync --generate --import --write-data --dev --backup");
+    console.log("  $ npx appwrite-utils-cli appwrite-create");
+    console.log("For more information, visit https://github.com/zachhandley/appwrite-utils");
+    console.log("");
+});
+// Parse and handle options
+program.action(async (options) => {
     const controller = new UtilsController();
-    let sync = false;
-    let runProd = false;
-    let runStaging = false;
-    let runDev = false;
-    let doBackup = false;
-    let wipeDatabases = false;
-    let wipeUsers = false;
-    let generateSchemas = false;
-    let importData = false;
-    let wipeDocuments = false;
-    let shouldWriteFile = false;
-    let endpoint;
-    let project;
-    let key;
-    if (args.includes("--sync")) {
-        sync = true;
-    }
-    if (args.includes("--prod")) {
-        runProd = true;
-    }
-    if (args.includes("--staging")) {
-        runStaging = true;
-    }
-    if (args.includes("--dev")) {
-        runDev = true;
-    }
-    if (args.includes("--wipe")) {
-        wipeDatabases = true;
-    }
-    if (args.includes("--wipe-docs") || args.includes("--wipeDocs")) {
-        wipeDocuments = true;
-    }
-    if (args.includes("--generate")) {
-        generateSchemas = true;
-    }
-    if (args.includes("--import")) {
-        importData = true;
-    }
-    if (args.includes("--backup")) {
-        doBackup = true;
-    }
-    if (args.includes("--wipe-users") || args.includes("--wipeUsers")) {
-        wipeUsers = true;
-    }
-    if (args.includes("--write-data") || args.includes("--writeData")) {
-        shouldWriteFile = true;
-    }
-    if (args.includes("--endpoint")) {
-        endpoint = args[args.indexOf("--endpoint") + 1];
-    }
-    if (args.includes("--project")) {
-        project = args[args.indexOf("--project") + 1];
-    }
-    if (args.includes("--key")) {
-        key = args[args.indexOf("--key") + 1];
-    }
-    if (args.includes("--init")) {
-        await controller.run({
-            sync: sync,
-            runProd: runProd,
-            runStaging: runStaging,
-            runDev: runDev,
-            doBackup: doBackup,
-            wipeDatabases: wipeDatabases,
-            wipeUsers: wipeUsers,
-            wipeDocumentStorage: wipeDocuments,
-            generateSchemas: true,
-            generateMockData: false,
-            importData: false,
-            checkDuplicates: false,
-            shouldWriteFile: shouldWriteFile,
-            endpoint: endpoint,
-            project: project,
-            key: key,
-        });
-    }
-    else {
-        await controller.run({
-            sync: sync,
-            runProd: runProd,
-            runStaging: runStaging,
-            runDev: runDev,
-            doBackup: doBackup,
-            wipeDatabases: wipeDatabases,
-            wipeDocumentStorage: wipeDocuments,
-            generateSchemas: generateSchemas,
-            generateMockData: false,
-            wipeUsers: wipeUsers,
-            importData: importData,
-            checkDuplicates: false,
-            shouldWriteFile: shouldWriteFile,
-            endpoint: endpoint,
-            project: project,
-            key: key,
-        });
-    }
-}
-main().catch(console.error);
+    try {
+        // Convert Commander options to the format expected by UtilsController
+        const setupOptions = {
+            sync: options.sync,
+            runProd: options.prod,
+            runStaging: options.staging,
+            runDev: options.dev,
+            doBackup: options.backup,
+            wipeDatabases: options.wipe,
+            wipeDocumentStorage: options.wipeDocs,
+            wipeUsers: options.wipeUsers,
+            generateSchemas: options.generate,
+            generateMockData: false, // Assuming this needs to be set based on other conditions
+            importData: options.import,
+            checkDuplicates: false, // Assuming this needs to be set based on other conditions
+            shouldWriteFile: options.writeData,
+            endpoint: options.endpoint,
+            project: options.project,
+            key: options.key,
+        };
+        await controller.run(setupOptions);
+        console.log("Operation completed successfully.");
+    }
+    catch (error) {
+        console.error("Error during operation:", error);
+    }
+});
+program.parse(process.argv);

package/dist/migrations/afterImportActions.d.ts

@@ -1,10 +1,7 @@
 import { Databases, Storage, type Models } from "node-appwrite";
-import type { AppwriteConfig } from "./schema.js";
+import { type AppwriteConfig } from "appwrite-utils";
 export declare const getDatabaseFromConfig: (config: AppwriteConfig) => Databases;
 export declare const getStorageFromConfig: (config: AppwriteConfig) => Storage;
-export interface AfterImportActions {
-    [key: string]: (config: AppwriteConfig, ...args: any[]) => Promise<any>;
-}
 export declare const afterImportActions: {
     updateCreatedDocument: (config: AppwriteConfig, dbId: string, collId: string, docId: string, data: any) => Promise<void>;
     checkAndUpdateFieldInDocument: (config: AppwriteConfig, dbId: string, collId: string, docId: string, fieldName: string, oldFieldValue: any, newFieldValue: any) => Promise<void>;

package/dist/migrations/afterImportActions.js

@@ -3,6 +3,7 @@ import path from "path";
 import fs from "fs";
 import os from "os";
 import { logger } from "./logging.js";
+import {} from "appwrite-utils";
 export const getDatabaseFromConfig = (config) => {
     if (!config.appwriteClient) {
         config.appwriteClient = new Client()

package/dist/migrations/appwriteToX.d.ts

@@ -1,93 +1,91 @@
 import { type Models } from "node-appwrite";
-import { type AppwriteConfig } from "./schema.js";
+import { type AppwriteConfig } from "appwrite-utils";
 export declare class AppwriteToX {
     config: AppwriteConfig;
     updatedConfig: AppwriteConfig;
     collToAttributeMap: Map<string, ({
-        key: string;
         type: "string";
-        error: string;
-        required: boolean;
-        array: boolean;
+        key: string;
         size: number;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: string | null | undefined;
         encrypted?: boolean | undefined;
         format?: string | null | undefined;
-        description?: string | Record<string, string> | null | undefined;
+        description?: string | Record<string, string> | undefined;
     } | {
-        key: string;
         type: "integer";
-        error: string;
-        required: boolean;
-        array: boolean;
-        min?: number | undefined;
-        max?: number | undefined;
+        key: string;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: number | null | undefined;
         description?: string | Record<string, string> | null | undefined;
-    } | {
-        key: string;
-        type: "float";
-        error: string;
-        required: boolean;
-        array: boolean;
         min?: number | undefined;
         max?: number | undefined;
+    } | {
+        type: "float";
+        key: string;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: number | null | undefined;
         description?: string | Record<string, string> | null | undefined;
+        min?: number | undefined;
+        max?: number | undefined;
     } | {
-        key: string;
         type: "boolean";
-        error: string;
-        required: boolean;
-        array: boolean;
+        key: string;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: boolean | null | undefined;
         description?: string | Record<string, string> | null | undefined;
     } | {
-        key: string;
         type: "datetime";
-        error: string;
-        required: boolean;
-        array: boolean;
+        key: string;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: string | null | undefined;
         description?: string | Record<string, string> | null | undefined;
     } | {
-        key: string;
         type: "email";
-        error: string;
-        required: boolean;
-        array: boolean;
+        key: string;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: string | null | undefined;
         description?: string | Record<string, string> | null | undefined;
     } | {
-        key: string;
         type: "ip";
-        error: string;
-        required: boolean;
-        array: boolean;
+        key: string;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: string | null | undefined;
         description?: string | Record<string, string> | null | undefined;
     } | {
-        key: string;
         type: "url";
-        error: string;
-        required: boolean;
-        array: boolean;
+        key: string;
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: string | null | undefined;
         description?: string | Record<string, string> | null | undefined;
     } | {
-        key: string;
         type: "enum";
-        error: string;
-        required: boolean;
-        array: boolean;
+        key: string;
         elements: string[];
+        array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
         xdefault?: string | null | undefined;
         description?: string | Record<string, string> | null | undefined;
     } | {
-        key: string;
         type: "relationship";
-        error: string;
-        required: boolean;
+        key: string;
         relatedCollection: string;
         relationType: "oneToMany" | "manyToOne" | "oneToOne" | "manyToMany";
         twoWay: boolean;
@@ -95,11 +93,13 @@ export declare class AppwriteToX {
         onDelete: "setNull" | "cascade" | "restrict";
         side: "parent" | "child";
         array?: boolean | undefined;
+        error?: string | undefined;
+        required?: boolean | undefined;
+        description?: string | Record<string, string> | null | undefined;
         importMapping?: {
             originalIdField: string;
             targetField?: string | undefined;
         } | undefined;
-        description?: string | Record<string, string> | null | undefined;
     })[]>;
     appwriteFolderPath: string;
     constructor(config: AppwriteConfig, appwriteFolderPath: string);

package/dist/migrations/appwriteToX.js

@@ -2,7 +2,7 @@ import { SchemaGenerator } from "./schemaStrings.js";
 import { Databases, Query } from "node-appwrite";
 import { fetchAllCollections } from "./collections.js";
 import { fetchAllDatabases } from "./databases.js";
-import { collectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, } from "./schema.js";
+import { collectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, } from "appwrite-utils";
 import { getDatabaseFromConfig } from "./afterImportActions.js";
 export class AppwriteToX {
     config;
@@ -52,6 +52,9 @@ export class AppwriteToX {
             const collections = await fetchAllCollections(database.$id, db);
             // Loop through each collection in the current database
             for (const collection of collections) {
+                if (!updatedConfig.collections) {
+                    updatedConfig.collections = [];
+                }
                 const existingCollectionIndex = updatedConfig.collections.findIndex((c) => c.name === collection.name);
                 // Parse the collection permissions and attributes
                 const collPermissions = this.parsePermissionsArray(collection.$permissions);
@@ -86,6 +89,7 @@ export class AppwriteToX {
                 const collIndexes = indexesSchema.parse(collection.indexes);
                 // Prepare the collection object to be added or updated
                 const collToPush = collectionSchema.parse({
+                    $id: collection.$id,
                     name: collection.name,
                     enabled: collection.enabled,
                     documentSecurity: collection.documentSecurity,
@@ -111,7 +115,7 @@ export class AppwriteToX {
     async toSchemas() {
         await this.appwriteSync(this.config);
         const generator = new SchemaGenerator(this.updatedConfig, this.appwriteFolderPath);
-        generator.updateYamlSchemas();
+        generator.updateTsSchemas();
         generator.generateSchemas();
     }
 }

package/dist/migrations/attributes.d.ts

@@ -1,4 +1,4 @@
 import { type Databases, type Models } from "node-appwrite";
-import { type Attribute } from "./schema.js";
+import { type Attribute } from "appwrite-utils";
 export declare const createOrUpdateAttribute: (db: Databases, dbId: string, collection: Models.Collection, attribute: Attribute) => Promise<void>;
 export declare const createUpdateCollectionAttributes: (db: Databases, dbId: string, collection: Models.Collection, attributes: Attribute[]) => Promise<void>;