appwrite-utils-cli 0.0.286 → 0.9.2

package/src/migrations/validationRules.ts

@@ -1,63 +1,63 @@
-import _ from "lodash";
-
-export interface ValidationRules {
-  [key: string]: (value: any, ...args: any[]) => boolean;
-}
-
-export const validationRules = {
-  isNumber: (value: any): boolean => _.isNumber(value),
-  isString: (value: any): boolean => _.isString(value),
-  isBoolean: (value: any): boolean => _.isBoolean(value),
-  isArray: (value: any): boolean => _.isArray(value),
-  isObject: (value: any): boolean =>
-    _.isObject(value) && !_.isArray(value) && !_.isFunction(value),
-  isNull: (value: any): boolean => _.isNull(value),
-  isValidEmail: (value: string): boolean =>
-    value.match(/^[\w\-\.]+@([\w-]+\.)+[\w-]{2,}$/) !== null,
-  isValidPhone: (value: string): boolean =>
-    value.match(/^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im) !==
-    null,
-  isValidPassword: (value: string): boolean =>
-    value.match(
-      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/
-    ) !== null,
-  isValidUrl: (value: string): boolean =>
-    value.match(
-      /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/
-    ) !== null,
-  isValidHex: (value: string): boolean =>
-    value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
-  isValidHexColor: (value: string): boolean =>
-    value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
-  isValidHexAlpha: (value: string): boolean =>
-    value.match(/^#([a-f0-9]{8}|[a-f0-9]{4})$/i) !== null,
-  isValidDate: (value: string): boolean =>
-    value.match(/^\d{4}-\d{2}-\d{2}$/) !== null,
-  isValidTime: (value: string): boolean =>
-    value.match(/^\d{2}:\d{2}(:\d{2})?$/) !== null,
-  isNullish: (value: any): boolean => _.isNull(value) || _.isUndefined(value),
-  isUndefined: (value: any): boolean => _.isUndefined(value),
-  isDefined: (value: any): boolean =>
-    !_.isUndefined(value) && !_.isNull(value) && !_.isEmpty(value),
-  isDate: (value: any): boolean => _.isDate(value),
-  isEmpty: (value: any): boolean => _.isEmpty(value),
-  isInteger: (value: any): boolean => _.isInteger(value),
-  isFloat: (value: any): boolean => _.isNumber(value) && !_.isInteger(value),
-  isArrayLike: (value: any): boolean => _.isArrayLike(value),
-  isArrayLikeObject: (value: any): boolean => _.isArrayLikeObject(value),
-  isFunction: (value: any): boolean => _.isFunction(value),
-  isLength: (value: any): boolean => _.isLength(value),
-  isMap: (value: any): boolean => _.isMap(value),
-  isSet: (value: any): boolean => _.isSet(value),
-  isRegExp: (value: any): boolean => _.isRegExp(value),
-  isSymbol: (value: any): boolean => _.isSymbol(value),
-  isObjectLike: (value: any): boolean => _.isObjectLike(value),
-  isPlainObject: (value: any): boolean => _.isPlainObject(value),
-  isSafeInteger: (value: any): boolean => _.isSafeInteger(value),
-  isTypedArray: (value: any): boolean => _.isTypedArray(value),
-  isEqual: (value: any, other: any): boolean => _.isEqual(value, other),
-  isMatch: (object: any, source: any): boolean => _.isMatch(object, source),
-  has: (object: any, path: string): boolean => _.has(object, path),
-  get: (object: any, path: string, defaultValue: any): any =>
-    _.get(object, path, defaultValue),
-};
+import _ from "lodash";
+
+export interface ValidationRules {
+  [key: string]: (value: any, ...args: any[]) => boolean;
+}
+
+export const validationRules = {
+  isNumber: (value: any): boolean => _.isNumber(value),
+  isString: (value: any): boolean => _.isString(value),
+  isBoolean: (value: any): boolean => _.isBoolean(value),
+  isArray: (value: any): boolean => _.isArray(value),
+  isObject: (value: any): boolean =>
+    _.isObject(value) && !_.isArray(value) && !_.isFunction(value),
+  isNull: (value: any): boolean => _.isNull(value),
+  isValidEmail: (value: string): boolean =>
+    value.match(/^[\w\-\.]+@([\w-]+\.)+[\w-]{2,}$/) !== null,
+  isValidPhone: (value: string): boolean =>
+    value.match(/^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im) !==
+    null,
+  isValidPassword: (value: string): boolean =>
+    value.match(
+      /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/
+    ) !== null,
+  isValidUrl: (value: string): boolean =>
+    value.match(
+      /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/
+    ) !== null,
+  isValidHex: (value: string): boolean =>
+    value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
+  isValidHexColor: (value: string): boolean =>
+    value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
+  isValidHexAlpha: (value: string): boolean =>
+    value.match(/^#([a-f0-9]{8}|[a-f0-9]{4})$/i) !== null,
+  isValidDate: (value: string): boolean =>
+    value.match(/^\d{4}-\d{2}-\d{2}$/) !== null,
+  isValidTime: (value: string): boolean =>
+    value.match(/^\d{2}:\d{2}(:\d{2})?$/) !== null,
+  isNullish: (value: any): boolean => _.isNull(value) || _.isUndefined(value),
+  isUndefined: (value: any): boolean => _.isUndefined(value),
+  isDefined: (value: any): boolean =>
+    !_.isUndefined(value) && !_.isNull(value) && !_.isEmpty(value),
+  isDate: (value: any): boolean => _.isDate(value),
+  isEmpty: (value: any): boolean => _.isEmpty(value),
+  isInteger: (value: any): boolean => _.isInteger(value),
+  isFloat: (value: any): boolean => _.isNumber(value) && !_.isInteger(value),
+  isArrayLike: (value: any): boolean => _.isArrayLike(value),
+  isArrayLikeObject: (value: any): boolean => _.isArrayLikeObject(value),
+  isFunction: (value: any): boolean => _.isFunction(value),
+  isLength: (value: any): boolean => _.isLength(value),
+  isMap: (value: any): boolean => _.isMap(value),
+  isSet: (value: any): boolean => _.isSet(value),
+  isRegExp: (value: any): boolean => _.isRegExp(value),
+  isSymbol: (value: any): boolean => _.isSymbol(value),
+  isObjectLike: (value: any): boolean => _.isObjectLike(value),
+  isPlainObject: (value: any): boolean => _.isPlainObject(value),
+  isSafeInteger: (value: any): boolean => _.isSafeInteger(value),
+  isTypedArray: (value: any): boolean => _.isTypedArray(value),
+  isEqual: (value: any, other: any): boolean => _.isEqual(value, other),
+  isMatch: (object: any, source: any): boolean => _.isMatch(object, source),
+  has: (object: any, path: string): boolean => _.has(object, path),
+  get: (object: any, path: string, defaultValue: any): any =>
+    _.get(object, path, defaultValue),
+};

package/src/schemas/authUser.ts

@@ -1,23 +1,23 @@
-import { z } from "zod";
-
-export const AuthUserSchema = z.object({
-  $id: z.string(),
-  $createdAt: z.string().optional(),
-  $updatedAt: z.string().optional(),
-  name: z.string().nullish(),
-  email: z.string().email("Invalid Email Address").nullish(),
-  phone: z.string().nullish(),
-  prefs: z.record(z.string()).optional().default({}),
-  labels: z.array(z.string()).optional().default([]),
-});
-
-export type AuthUser = z.infer<typeof AuthUserSchema>;
-
-export const AuthUserCreateSchema = AuthUserSchema.omit({
-  $id: true,
-}).extend({
-  userId: z.string().optional(),
-  password: z.string().optional(),
-});
-
-export type AuthUserCreate = z.infer<typeof AuthUserCreateSchema>;
+import { z } from "zod";
+
+export const AuthUserSchema = z.object({
+  $id: z.string(),
+  $createdAt: z.string().optional(),
+  $updatedAt: z.string().optional(),
+  name: z.string().nullish(),
+  email: z.string().email("Invalid Email Address").nullish(),
+  phone: z.string().nullish(),
+  prefs: z.record(z.string()).optional().default({}),
+  labels: z.array(z.string()).optional().default([]),
+});
+
+export type AuthUser = z.infer<typeof AuthUserSchema>;
+
+export const AuthUserCreateSchema = AuthUserSchema.omit({
+  $id: true,
+}).extend({
+  userId: z.string().optional(),
+  password: z.string().optional(),
+});
+
+export type AuthUserCreate = z.infer<typeof AuthUserCreateSchema>;

package/src/setup.ts

@@ -1,8 +1,8 @@
-#!/usr/bin/env node
-import { setupDirsFiles } from "./utils/setupFiles.js";
-
-const args = process.argv.slice(2);
-
-const genExample = args.includes("--example");
-
-setupDirsFiles(genExample);
+#!/usr/bin/env node
+import { setupDirsFiles } from "./utils/setupFiles.js";
+
+const args = process.argv.slice(2);
+
+const genExample = args.includes("--example");
+
+setupDirsFiles(genExample);

package/src/storage/methods.ts

@@ -0,0 +1,371 @@
+import {
+  Compression,
+  Databases,
+  Permission,
+  Query,
+  Role,
+  Storage,
+  type Models,
+} from "node-appwrite";
+import { tryAwaitWithRetry, type AppwriteConfig } from "appwrite-utils";
+import { getClientFromConfig } from "../utils/getClientFromConfig.js";
+import { ulid } from "ulidx";
+import type { BackupCreate } from "./schemas.js";
+import { logOperation } from "../migrations/helper.js";
+import { splitIntoBatches } from "../migrations/migrationHelper.js";
+import { retryFailedPromises } from "../utils/retryFailedPromises.js";
+import { InputFile } from "node-appwrite/file";
+
+export const getStorage = (config: AppwriteConfig) => {
+  const client = getClientFromConfig(config);
+  return new Storage(client!);
+};
+
+export const listBuckets = async (
+  storage: Storage,
+  queries?: string[],
+  search?: string
+) => {
+  return await storage.listBuckets(queries, search);
+};
+
+export const getBucket = async (storage: Storage, bucketId: string) => {
+  return await storage.getBucket(bucketId);
+};
+
+export const createBucket = async (
+  storage: Storage,
+  bucket: Omit<Models.Bucket, "$id" | "$createdAt" | "$updatedAt">,
+  bucketId?: string
+) => {
+  return await storage.createBucket(
+    bucketId ?? ulid(),
+    bucket.name,
+    bucket.$permissions,
+    bucket.fileSecurity,
+    bucket.enabled,
+    bucket.maximumFileSize,
+    bucket.allowedFileExtensions,
+    bucket.compression as Compression,
+    bucket.encryption,
+    bucket.antivirus
+  );
+};
+
+export const updateBucket = async (
+  storage: Storage,
+  bucket: Models.Bucket,
+  bucketId: string
+) => {
+  return await storage.updateBucket(
+    bucketId,
+    bucket.name,
+    bucket.$permissions,
+    bucket.fileSecurity,
+    bucket.enabled,
+    bucket.maximumFileSize,
+    bucket.allowedFileExtensions,
+    bucket.compression as Compression,
+    bucket.encryption,
+    bucket.antivirus
+  );
+};
+
+export const deleteBucket = async (storage: Storage, bucketId: string) => {
+  return await storage.deleteBucket(bucketId);
+};
+
+export const getFile = async (
+  storage: Storage,
+  bucketId: string,
+  fileId: string
+) => {
+  return await storage.getFile(bucketId, fileId);
+};
+
+export const listFiles = async (
+  storage: Storage,
+  bucketId: string,
+  queries?: string[],
+  search?: string
+) => {
+  return await storage.listFiles(bucketId, queries, search);
+};
+
+export const deleteFile = async (
+  storage: Storage,
+  bucketId: string,
+  fileId: string
+) => {
+  return await storage.deleteFile(bucketId, fileId);
+};
+
+export const wipeDocumentStorage = async (
+  storage: Storage,
+  bucketId: string
+): Promise<void> => {
+  console.log(`Wiping storage for bucket ID: ${bucketId}`);
+  let moreFiles = true;
+  let lastFileId: string | undefined;
+  const allFiles: string[] = [];
+  while (moreFiles) {
+    const queries = [Query.limit(100)]; // Adjust the limit as needed
+    if (lastFileId) {
+      queries.push(Query.cursorAfter(lastFileId));
+    }
+    const filesPulled = await tryAwaitWithRetry(
+      async () => await storage.listFiles(bucketId, queries)
+    );
+    if (filesPulled.files.length === 0) {
+      console.log("No files found, done!");
+      moreFiles = false;
+      break;
+    } else if (filesPulled.files.length > 0) {
+      const fileIds = filesPulled.files.map((file) => file.$id);
+      allFiles.push(...fileIds);
+    }
+    moreFiles = filesPulled.files.length === 100; // Adjust based on the limit
+    if (moreFiles) {
+      lastFileId = filesPulled.files[filesPulled.files.length - 1].$id;
+    }
+  }
+
+  for (const fileId of allFiles) {
+    console.log(`Deleting file: ${fileId}`);
+    await tryAwaitWithRetry(
+      async () => await storage.deleteFile(bucketId, fileId)
+    );
+  }
+  console.log(`All files in bucket ${bucketId} have been deleted.`);
+};
+
+export const initOrGetDocumentStorage = async (
+  storage: Storage,
+  config: AppwriteConfig,
+  dbId: string,
+  bucketName?: string
+) => {
+  const bucketId =
+    bucketName ??
+    `${config.documentBucketId}_${dbId.toLowerCase().replace(" ", "")}`;
+  try {
+    return await tryAwaitWithRetry(
+      async () => await storage.getBucket(bucketId)
+    );
+  } catch (e) {
+    return await tryAwaitWithRetry(
+      async () =>
+        await storage.createBucket(bucketId, `${dbId} Storage`, [
+          Permission.read(Role.any()),
+          Permission.create(Role.users()),
+          Permission.update(Role.users()),
+          Permission.delete(Role.users()),
+        ])
+    );
+  }
+};
+
+export const initOrGetBackupStorage = async (
+  config: AppwriteConfig,
+  storage: Storage
+) => {
+  try {
+    return await tryAwaitWithRetry(
+      async () => await storage.getBucket("backup")
+    );
+  } catch (e) {
+    return await initOrGetDocumentStorage(
+      storage,
+      config,
+      "backups",
+      "Database Backups"
+    );
+  }
+};
+
+export const backupDatabase = async (
+  config: AppwriteConfig,
+  database: Databases,
+  databaseId: string,
+  storage: Storage
+): Promise<void> => {
+  console.log("---------------------------------");
+  console.log("Starting Database Backup of " + databaseId);
+  console.log("---------------------------------");
+
+  let data: BackupCreate = {
+    database: "",
+    collections: [],
+    documents: [],
+  };
+
+  const backupOperation = await logOperation(database, databaseId, {
+    operationType: "backup",
+    collectionId: "",
+    data: "Starting backup...",
+    progress: 0,
+    total: 100,
+    error: "",
+    status: "in_progress",
+  });
+
+  try {
+    const db = await tryAwaitWithRetry(
+      async () => await database.get(databaseId)
+    );
+    data.database = JSON.stringify(db);
+
+    let lastCollectionId = "";
+    let moreCollections = true;
+    let progress = 0;
+    let total = 0;
+
+    while (moreCollections) {
+      const collectionResponse = await tryAwaitWithRetry(
+        async () =>
+          await database.listCollections(databaseId, [
+            Query.limit(500),
+            ...(lastCollectionId ? [Query.cursorAfter(lastCollectionId)] : []),
+          ])
+      );
+
+      total += collectionResponse.collections.length;
+
+      for (const {
+        $id: collectionId,
+        name: collectionName,
+      } of collectionResponse.collections) {
+        try {
+          const collection = await tryAwaitWithRetry(
+            async () => await database.getCollection(databaseId, collectionId)
+          );
+          progress++;
+          data.collections.push(JSON.stringify(collection));
+
+          let lastDocumentId = "";
+          let moreDocuments = true;
+          let collectionDocumentCount = 0;
+
+          while (moreDocuments) {
+            const documentResponse = await tryAwaitWithRetry(
+              async () =>
+                await database.listDocuments(databaseId, collectionId, [
+                  Query.limit(500),
+                  ...(lastDocumentId
+                    ? [Query.cursorAfter(lastDocumentId)]
+                    : []),
+                ])
+            );
+
+            total += documentResponse.documents.length;
+            collectionDocumentCount += documentResponse.documents.length;
+
+            const documentPromises = documentResponse.documents.map(
+              ({ $id: documentId }) =>
+                database.getDocument(databaseId, collectionId, documentId)
+            );
+
+            const promiseBatches = splitIntoBatches(documentPromises);
+            const documentsPulled = [];
+            for (const batch of promiseBatches) {
+              const successfulDocuments = await retryFailedPromises(batch);
+              documentsPulled.push(...successfulDocuments);
+            }
+
+            data.documents.push({
+              collectionId: collectionId,
+              data: JSON.stringify(documentsPulled),
+            });
+            progress += documentsPulled.length;
+
+            await logOperation(
+              database,
+              databaseId,
+              {
+                operationType: "backup",
+                collectionId: collectionId,
+                data: `Backing up, ${data.collections.length} collections so far`,
+                progress: progress,
+                total: total,
+                error: "",
+                status: "in_progress",
+              },
+              backupOperation.$id
+            );
+
+            moreDocuments = documentResponse.documents.length === 500;
+            if (moreDocuments) {
+              lastDocumentId =
+                documentResponse.documents[
+                  documentResponse.documents.length - 1
+                ].$id;
+            }
+          }
+
+          console.log(
+            `Collection ${collectionName} backed up with ${collectionDocumentCount} documents.`
+          );
+        } catch (error) {
+          console.log(
+            `Collection ${collectionName} must not exist, continuing...`
+          );
+          continue;
+        }
+      }
+
+      moreCollections = collectionResponse.collections.length === 500;
+      if (moreCollections) {
+        lastCollectionId =
+          collectionResponse.collections[
+            collectionResponse.collections.length - 1
+          ].$id;
+      }
+    }
+
+    const bucket = await initOrGetDocumentStorage(storage, config, databaseId);
+    const inputFile = InputFile.fromPlainText(
+      JSON.stringify(data),
+      `${new Date().toISOString()}-${databaseId}.json`
+    );
+    const fileCreated = await storage.createFile(
+      bucket!.$id,
+      ulid(),
+      inputFile
+    );
+
+    await logOperation(
+      database,
+      databaseId,
+      {
+        operationType: "backup",
+        collectionId: "",
+        data: fileCreated.$id,
+        progress: 100,
+        total: total,
+        error: "",
+        status: "completed",
+      },
+      backupOperation.$id
+    );
+
+    console.log("---------------------------------");
+    console.log("Database Backup Complete");
+    console.log("---------------------------------");
+  } catch (error) {
+    console.error("Error during backup:", error);
+    await logOperation(
+      database,
+      databaseId,
+      {
+        operationType: "backup",
+        collectionId: "",
+        data: "Backup failed",
+        progress: 0,
+        total: 100,
+        error: String(error),
+        status: "error",
+      },
+      backupOperation.$id
+    );
+  }
+};