appwrite-utils-cli 0.0.285 → 0.9.0

package/src/storage/schemas.ts

@@ -0,0 +1,205 @@
+import { z } from "zod";
+import {
+  attributeSchema,
+  type Attribute,
+  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 type Backup = z.infer<typeof BackupSchema>;
+
+export const BackupCreateSchema = BackupSchema.omit({
+  $id: true,
+  $createdAt: true,
+  $updatedAt: true,
+});
+
+export type BackupCreate = z.infer<typeof BackupCreateSchema>;
+
+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 type Batch = z.infer<typeof BatchSchema>;
+
+export const BatchCreateSchema = BatchSchema.omit({
+  $id: true,
+  $createdAt: true,
+  $updatedAt: true,
+});
+
+export type BatchCreate = z.infer<typeof BatchCreateSchema>;
+
+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 type Operation = z.infer<typeof OperationSchema>;
+
+export const OperationCreateSchema = OperationSchema.omit({
+  $id: true,
+  $createdAt: true,
+  $updatedAt: true,
+});
+
+export type OperationCreate = z.infer<typeof OperationCreateSchema>;
+
+export const getMigrationCollectionSchemas = () => {
+  const currentOperationsAttributes: Attribute[] = [
+    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: Attribute[] = [
+    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/src/types.ts

@@ -1,9 +1,9 @@
-export type { ValidationRules } from "./migrations/validationRules.js";
-export {
-  type AuthUserCreate,
-  AuthUserCreateSchema,
-  type AuthUser,
-  AuthUserSchema,
-} from "./schemas/authUser.js";
-export { validationRules } from "./migrations/validationRules.js";
-export { afterImportActions } from "./migrations/afterImportActions.js";
+export type { ValidationRules } from "./migrations/validationRules.js";
+export {
+  type AuthUserCreate,
+  AuthUserCreateSchema,
+  type AuthUser,
+  AuthUserSchema,
+} from "./schemas/authUser.js";
+export { validationRules } from "./migrations/validationRules.js";
+export { afterImportActions } from "./migrations/afterImportActions.js";

package/src/utils/getClientFromConfig.ts

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

package/src/utils/helperFunctions.ts

@@ -1,127 +1,181 @@
-import type { Models, Storage } from "node-appwrite";
-import fs from "node:fs";
-import path from "node:path";
-import type { CollectionImportData } from "../migrations/dataLoader.js";
-import type { ConfigCollection } from "appwrite-utils";
-
-export const toPascalCase = (str: string): string => {
-  return (
-    str
-      // Split the string into words on spaces or camelCase transitions
-      .split(/(?:\s+)|(?:([A-Z][a-z]+))/g)
-      // Filter out empty strings that can appear due to the split regex
-      .filter(Boolean)
-      // Capitalize the first letter of each word and join them together
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join("")
-  );
-};
-
-export const toCamelCase = (str: string): string => {
-  return str
-    .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) =>
-      index === 0 ? word.toLowerCase() : word.toUpperCase()
-    )
-    .replace(/\s+/g, "");
-};
-
-export const ensureDirectoryExistence = (filePath: string) => {
-  const dirname = path.dirname(filePath);
-  if (fs.existsSync(dirname)) {
-    return true;
-  }
-  ensureDirectoryExistence(dirname);
-  fs.mkdirSync(dirname);
-};
-
-export const writeFileSync = (
-  filePath: string,
-  content: string,
-  options: { flag: string }
-) => {
-  ensureDirectoryExistence(filePath);
-  fs.writeFileSync(filePath, content, options);
-};
-
-export const readFileSync = (filePath: string) => {
-  return fs.readFileSync(filePath, "utf8");
-};
-
-export const existsSync = (filePath: string) => {
-  return fs.existsSync(filePath);
-};
-
-export const mkdirSync = (filePath: string) => {
-  ensureDirectoryExistence(filePath);
-  fs.mkdirSync(filePath);
-};
-
-export const readdirSync = (filePath: string) => {
-  return fs.readdirSync(filePath);
-};
-
-export const areCollectionNamesSame = (a: string, b: string) => {
-  return (
-    a.toLowerCase().trim().replace(" ", "") ===
-    b.toLowerCase().trim().replace(" ", "")
-  );
-};
-
-/**
- * Generates the view URL for a specific file based on the provided endpoint, project ID, bucket ID, file ID, and optional JWT token.
- *
- * @param {string} endpoint - the base URL endpoint
- * @param {string} projectId - the ID of the project
- * @param {string} bucketId - the ID of the bucket
- * @param {string} fileId - the ID of the file
- * @param {Models.Jwt} [jwt] - optional JWT token generated via the Appwrite SDK
- * @return {string} the generated view URL for the file
- */
-export const getFileViewUrl = (
-  endpoint: string,
-  projectId: string,
-  bucketId: string,
-  fileId: string,
-  jwt?: Models.Jwt
-) => {
-  return `${endpoint}/storage/buckets/${bucketId}/files/${fileId}/view?project=${projectId}${
-    jwt ? `&jwt=${jwt.jwt}` : ""
-  }`;
-};
-
-/**
- * Generates a download URL for a file based on the provided endpoint, project ID, bucket ID, file ID, and optionally a JWT.
- *
- * @param {string} endpoint - The base URL endpoint.
- * @param {string} projectId - The ID of the project.
- * @param {string} bucketId - The ID of the bucket.
- * @param {string} fileId - The ID of the file.
- * @param {Models.Jwt} [jwt] - Optional JWT object for authentication with Appwrite.
- * @return {string} The complete download URL for the file.
- */
-export const getFileDownloadUrl = (
-  endpoint: string,
-  projectId: string,
-  bucketId: string,
-  fileId: string,
-  jwt?: Models.Jwt
-) => {
-  return `${endpoint}/storage/buckets/${bucketId}/files/${fileId}/download?project=${projectId}${
-    jwt ? `&jwt=${jwt.jwt}` : ""
-  }`;
-};
-
-export const finalizeByAttributeMap = async (
-  appwriteFolderPath: string,
-  collection: ConfigCollection,
-  item: CollectionImportData["data"][number]
-) => {
-  const schemaFolderPath = path.join(appwriteFolderPath, "schemas");
-  const zodSchema = await import(
-    `${schemaFolderPath}/${toCamelCase(collection.name)}.ts`
-  );
-  return zodSchema.parse({
-    ...item.context,
-    ...item.finalData,
-  });
-};
+import {
+  AppwriteException,
+  Client,
+  type Models,
+  type Storage,
+} from "node-appwrite";
+import fs from "node:fs";
+import path from "node:path";
+import type { CollectionImportData } from "../migrations/dataLoader.js";
+import type { ConfigCollection } from "appwrite-utils";
+
+export const toPascalCase = (str: string): string => {
+  return (
+    str
+      // Split the string into words on spaces or camelCase transitions
+      .split(/(?:\s+)|(?:([A-Z][a-z]+))/g)
+      // Filter out empty strings that can appear due to the split regex
+      .filter(Boolean)
+      // Capitalize the first letter of each word and join them together
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join("")
+  );
+};
+
+export const toCamelCase = (str: string): string => {
+  return str
+    .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) =>
+      index === 0 ? word.toLowerCase() : word.toUpperCase()
+    )
+    .replace(/\s+/g, "");
+};
+
+export const ensureDirectoryExistence = (filePath: string) => {
+  const dirname = path.dirname(filePath);
+  if (fs.existsSync(dirname)) {
+    return true;
+  }
+  ensureDirectoryExistence(dirname);
+  fs.mkdirSync(dirname);
+};
+
+export const writeFileSync = (
+  filePath: string,
+  content: string,
+  options: { flag: string }
+) => {
+  ensureDirectoryExistence(filePath);
+  fs.writeFileSync(filePath, content, options);
+};
+
+export const readFileSync = (filePath: string) => {
+  return fs.readFileSync(filePath, "utf8");
+};
+
+export const existsSync = (filePath: string) => {
+  return fs.existsSync(filePath);
+};
+
+export const mkdirSync = (filePath: string) => {
+  ensureDirectoryExistence(filePath);
+  fs.mkdirSync(filePath);
+};
+
+export const readdirSync = (filePath: string) => {
+  return fs.readdirSync(filePath);
+};
+
+export const areCollectionNamesSame = (a: string, b: string) => {
+  return (
+    a.toLowerCase().trim().replace(" ", "") ===
+    b.toLowerCase().trim().replace(" ", "")
+  );
+};
+
+/**
+ * Generates the view URL for a specific file based on the provided endpoint, project ID, bucket ID, file ID, and optional JWT token.
+ *
+ * @param {string} endpoint - the base URL endpoint
+ * @param {string} projectId - the ID of the project
+ * @param {string} bucketId - the ID of the bucket
+ * @param {string} fileId - the ID of the file
+ * @param {Models.Jwt} [jwt] - optional JWT token generated via the Appwrite SDK
+ * @return {string} the generated view URL for the file
+ */
+export const getFileViewUrl = (
+  endpoint: string,
+  projectId: string,
+  bucketId: string,
+  fileId: string,
+  jwt?: Models.Jwt
+) => {
+  return `${endpoint}/storage/buckets/${bucketId}/files/${fileId}/view?project=${projectId}${
+    jwt ? `&jwt=${jwt.jwt}` : ""
+  }`;
+};
+
+/**
+ * Generates a download URL for a file based on the provided endpoint, project ID, bucket ID, file ID, and optionally a JWT.
+ *
+ * @param {string} endpoint - The base URL endpoint.
+ * @param {string} projectId - The ID of the project.
+ * @param {string} bucketId - The ID of the bucket.
+ * @param {string} fileId - The ID of the file.
+ * @param {Models.Jwt} [jwt] - Optional JWT object for authentication with Appwrite.
+ * @return {string} The complete download URL for the file.
+ */
+export const getFileDownloadUrl = (
+  endpoint: string,
+  projectId: string,
+  bucketId: string,
+  fileId: string,
+  jwt?: Models.Jwt
+) => {
+  return `${endpoint}/storage/buckets/${bucketId}/files/${fileId}/download?project=${projectId}${
+    jwt ? `&jwt=${jwt.jwt}` : ""
+  }`;
+};
+
+export const finalizeByAttributeMap = async (
+  appwriteFolderPath: string,
+  collection: ConfigCollection,
+  item: CollectionImportData["data"][number]
+) => {
+  const schemaFolderPath = path.join(appwriteFolderPath, "schemas");
+  const zodSchema = await import(
+    `${schemaFolderPath}/${toCamelCase(collection.name)}.ts`
+  );
+  return zodSchema.parse({
+    ...item.context,
+    ...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 <T>(
+  createFunction: () => Promise<T>,
+  attemptNum: number = 0,
+  throwError: boolean = false
+): Promise<T> => {
+  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: string,
+  projectId: string,
+  apiKey: string
+) => {
+  return new Client()
+    .setEndpoint(endpoint)
+    .setProject(projectId)
+    .setKey(apiKey);
+};

package/src/utils/index.ts

@@ -1,2 +1,2 @@
-export * from "./helperFunctions.js";
-export * from "./setupFiles.js";
+export * from "./helperFunctions.js";
+export * from "./setupFiles.js";

package/src/utils/loadConfigs.ts

@@ -1,59 +1,59 @@
-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 => {
-  if (dir === "node_modules") {
-    return null;
-  }
-  const files = fs.readdirSync(dir, { withFileTypes: true });
-
-  for (const file of files) {
-    if (file.isDirectory() && file.name !== "node_modules") {
-      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");
-    console.log(`Loading config from: ${configPath}`);
-    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
-  }
-};
+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 => {
+  if (dir === "node_modules") {
+    return null;
+  }
+  const files = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const file of files) {
+    if (file.isDirectory() && file.name !== "node_modules") {
+      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");
+    console.log(`Loading config from: ${configPath}`);
+    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
+  }
+};