appwrite-utils-cli 0.0.285 → 0.9.0

package/dist/storage/schemas.js

@@ -0,0 +1,175 @@
+import { z } from "zod";
+import { attributeSchema, parseAttribute, CollectionCreateSchema, } from "appwrite-utils";
+export const BackupSchema = z.object({
+    $id: z.string(),
+    $createdAt: z.string(),
+    $updatedAt: z.string(),
+    database: z.string(),
+    collections: z.array(z.string()),
+    documents: z
+        .array(z.object({
+        collectionId: z.string(),
+        data: z.string(),
+    }))
+        .default([]),
+});
+export const BackupCreateSchema = BackupSchema.omit({
+    $id: true,
+    $createdAt: true,
+    $updatedAt: true,
+});
+export const BatchSchema = z.object({
+    $id: z.string(),
+    $createdAt: z.string(),
+    $updatedAt: z.string(),
+    data: z.string().describe("The serialized data for this batch"),
+    processed: z
+        .boolean()
+        .default(false)
+        .describe("Whether the batch has been processed"),
+});
+export const BatchCreateSchema = BatchSchema.omit({
+    $id: true,
+    $createdAt: true,
+    $updatedAt: true,
+});
+export const OperationSchema = z.object({
+    $id: z.string(),
+    $createdAt: z.string(),
+    $updatedAt: z.string(),
+    operationType: z.string(),
+    collectionId: z.string(),
+    data: z.any(),
+    batches: z.array(z.string()).default([]).optional(),
+    progress: z.number(),
+    total: z.number(),
+    error: z.string(),
+    status: z
+        .enum([
+        "pending",
+        "ready",
+        "in_progress",
+        "completed",
+        "error",
+        "cancelled",
+    ])
+        .default("pending"),
+});
+export const OperationCreateSchema = OperationSchema.omit({
+    $id: true,
+    $createdAt: true,
+    $updatedAt: true,
+});
+export const getMigrationCollectionSchemas = () => {
+    const currentOperationsAttributes = [
+        parseAttribute({
+            key: "operationType",
+            type: "string",
+            error: "Invalid Operation Type",
+            size: 50,
+            required: true,
+            array: false,
+            xdefault: null,
+        }),
+        attributeSchema.parse({
+            key: "collectionId",
+            type: "string",
+            error: "Invalid Collection Id",
+            size: 50,
+            array: false,
+            xdefault: null,
+        }),
+        attributeSchema.parse({
+            key: "batches",
+            type: "string",
+            error: "Invalid Batches",
+            size: 1073741824,
+            array: true,
+        }),
+        attributeSchema.parse({
+            key: "data",
+            type: "string",
+            error: "Invalid Data",
+            size: 1073741824,
+        }),
+        attributeSchema.parse({
+            key: "progress",
+            type: "integer",
+            error: "Invalid Progress",
+            required: true,
+            array: false,
+        }),
+        attributeSchema.parse({
+            key: "total",
+            type: "integer",
+            error: "Invalid Total",
+            required: true,
+            array: false,
+        }),
+        attributeSchema.parse({
+            key: "error",
+            type: "string",
+            error: "Operation Error",
+            required: false,
+            array: false,
+        }),
+        attributeSchema.parse({
+            key: "status",
+            type: "enum",
+            elements: [
+                "pending",
+                "ready",
+                "in_progress",
+                "completed",
+                "error",
+                "cancelled",
+            ],
+            error: "Invalid Status",
+            array: false,
+            xdefault: "pending",
+        }),
+    ];
+    const currentOperationsConfig = CollectionCreateSchema.parse({
+        name: "CurrentOperations",
+        enabled: true,
+        documentSecurity: false,
+        attributes: [],
+        indexes: [],
+    });
+    const batchesAttributes = [
+        attributeSchema.parse({
+            key: "data",
+            type: "string",
+            size: 1073741824,
+            error: "Invalid Data",
+            required: true,
+            array: false,
+        }),
+        attributeSchema.parse({
+            key: "processed",
+            type: "boolean",
+            error: "Invalid Processed",
+            required: true,
+            array: false,
+            xdefault: false,
+        }),
+    ];
+    const batchesConfig = CollectionCreateSchema.parse({
+        name: "Batches",
+        enabled: true,
+        documentSecurity: false,
+        attributes: [],
+        indexes: [],
+    });
+    const toReturn = {
+        CurrentOperations: {
+            collection: currentOperationsConfig,
+            attributes: currentOperationsAttributes,
+        },
+        Batches: {
+            collection: batchesConfig,
+            attributes: batchesAttributes,
+        },
+    };
+    return toReturn;
+};

package/dist/utils/getClientFromConfig.d.ts

@@ -0,0 +1,4 @@
+import { type AppwriteConfig } from "appwrite-utils";
+import { Client } from "node-appwrite";
+export declare const getClientFromConfig: (config: AppwriteConfig) => Client | undefined;
+export declare const getClient: (endpoint: string, project: string, key: string) => Client;

package/dist/utils/getClientFromConfig.js

@@ -0,0 +1,16 @@
+import {} from "appwrite-utils";
+import { Client } from "node-appwrite";
+export const getClientFromConfig = (config) => {
+    let appwriteClient;
+    if (!config.appwriteClient) {
+        appwriteClient = new Client()
+            .setEndpoint(config.appwriteEndpoint)
+            .setProject(config.appwriteProject)
+            .setKey(config.appwriteKey);
+        config.appwriteClient = appwriteClient;
+    }
+    return appwriteClient;
+};
+export const getClient = (endpoint, project, key) => {
+    return new Client().setEndpoint(endpoint).setProject(project).setKey(key);
+};

package/dist/utils/helperFunctions.d.ts

@@ -1,4 +1,4 @@
-import type { Models } from "node-appwrite";
+import { Client, type Models } from "node-appwrite";
 import type { CollectionImportData } from "../migrations/dataLoader.js";
 import type { ConfigCollection } from "appwrite-utils";
 export declare const toPascalCase: (str: string) => string;
@@ -35,3 +35,13 @@ export declare const getFileViewUrl: (endpoint: string, projectId: string, bucke
  */
 export declare const getFileDownloadUrl: (endpoint: string, projectId: string, bucketId: string, fileId: string, jwt?: Models.Jwt) => string;
 export declare const finalizeByAttributeMap: (appwriteFolderPath: string, collection: ConfigCollection, item: CollectionImportData["data"][number]) => Promise<any>;
+export declare let numTimesFailedTotal: number;
+/**
+ * Tries to execute the given createFunction and retries up to 5 times if it fails.
+ *
+ * @param {() => Promise<any>} createFunction - The function to be executed.
+ * @param {number} [attemptNum=0] - The number of attempts made so far (default: 0).
+ * @return {Promise<any>} - A promise that resolves to the result of the createFunction or rejects with an error if it fails after 5 attempts.
+ */
+export declare const tryAwaitWithRetry: <T>(createFunction: () => Promise<T>, attemptNum?: number, throwError?: boolean) => Promise<T>;
+export declare const getAppwriteClient: (endpoint: string, projectId: string, apiKey: string) => Client;

package/dist/utils/helperFunctions.js

@@ -1,3 +1,4 @@
+import { AppwriteException, Client, } from "node-appwrite";
 import fs from "node:fs";
 import path from "node:path";
 export const toPascalCase = (str) => {
@@ -78,3 +79,40 @@ export const finalizeByAttributeMap = async (appwriteFolderPath, collection, ite
         ...item.finalData,
     });
 };
+export let numTimesFailedTotal = 0;
+/**
+ * Tries to execute the given createFunction and retries up to 5 times if it fails.
+ *
+ * @param {() => Promise<any>} createFunction - The function to be executed.
+ * @param {number} [attemptNum=0] - The number of attempts made so far (default: 0).
+ * @return {Promise<any>} - A promise that resolves to the result of the createFunction or rejects with an error if it fails after 5 attempts.
+ */
+export const tryAwaitWithRetry = async (createFunction, attemptNum = 0, throwError = false) => {
+    try {
+        return await createFunction();
+    }
+    catch (error) {
+        if (error instanceof AppwriteException &&
+            (error.message.toLowerCase().includes("fetch failed") ||
+                error.message.toLowerCase().includes("server error"))) {
+            numTimesFailedTotal++;
+            console.log(`Fetch failed on attempt ${attemptNum}. Retrying...`);
+            if (attemptNum > 5) {
+                throw error;
+            }
+            return tryAwaitWithRetry(createFunction, attemptNum + 1);
+        }
+        if (throwError) {
+            throw error;
+        }
+        console.error("Error during retryAwait function: " + error);
+        // @ts-ignore
+        return Promise.resolve();
+    }
+};
+export const getAppwriteClient = (endpoint, projectId, apiKey) => {
+    return new Client()
+        .setEndpoint(endpoint)
+        .setProject(projectId)
+        .setKey(apiKey);
+};

package/dist/utils/retryFailedPromises.d.ts

@@ -0,0 +1,2 @@
+import type { Models } from "node-appwrite";
+export declare const retryFailedPromises: (batch: Promise<Models.Document>[], maxRetries?: number) => Promise<PromiseSettledResult<Models.Document>[]>;

package/dist/utils/retryFailedPromises.js

@@ -0,0 +1,21 @@
+export const retryFailedPromises = async (batch, maxRetries = 3) => {
+    const results = await Promise.allSettled(batch);
+    const toRetry = [];
+    results.forEach((result, index) => {
+        if (result.status === "rejected") {
+            console.error("Promise rejected with reason:", result.reason);
+            if (maxRetries > 0) {
+                toRetry.push(batch[index]);
+            }
+        }
+    });
+    if (toRetry.length > 0) {
+        console.log(`Retrying ${toRetry.length} promises`);
+        return retryFailedPromises(toRetry, maxRetries - 1);
+    }
+    else {
+        return results
+            .filter((result) => result.status === "fulfilled")
+            .map((result) => result);
+    }
+};

package/dist/utils/schemaStrings.d.ts

@@ -0,0 +1,13 @@
+import type { AppwriteConfig, Attribute } from "appwrite-utils";
+export declare class SchemaGenerator {
+    private relationshipMap;
+    private config;
+    private appwriteFolderPath;
+    constructor(config: AppwriteConfig, appwriteFolderPath: string);
+    updateTsSchemas(): void;
+    private extractRelationships;
+    private addRelationship;
+    generateSchemas(): void;
+    createSchemaString: (name: string, attributes: Attribute[]) => string;
+    typeToZod: (attribute: Attribute) => string;
+}