appwrite-utils-cli 0.10.85 → 1.0.1

package/src/migrations/backup.ts

@@ -1,205 +0,0 @@
-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/migrations/databases.ts

@@ -1,39 +0,0 @@
-import {
-  Client,
-  Databases,
-  IndexType,
-  Query,
-  type Models,
-} from "node-appwrite";
-import {
-  getAppwriteClient,
-  tryAwaitWithRetry,
-} from "../utils/helperFunctions.js";
-
-export const fetchAllDatabases = async (
-  database: Databases
-): Promise<Models.Database[]> => {
-  const databases = await tryAwaitWithRetry(
-    async () => await database.list([Query.limit(25)])
-  );
-  if (!databases) return [];
-  const allDatabases = databases.databases;
-  if (allDatabases.length === 0) return [];
-  let lastDatabaseId = allDatabases[allDatabases.length - 1].$id;
-  if (databases.databases.length < 25) {
-    return allDatabases;
-  } else {
-    while (lastDatabaseId) {
-      const databases = await database.list([
-        Query.limit(25),
-        Query.cursorAfter(lastDatabaseId),
-      ]);
-      allDatabases.push(...databases.databases);
-      if (databases.databases.length < 25) {
-        break;
-      }
-      lastDatabaseId = databases.databases[databases.databases.length - 1].$id;
-    }
-  }
-  return allDatabases;
-};

package/src/migrations/dbHelpers.ts

@@ -1,92 +0,0 @@
-import type {
-  AppwriteConfig,
-  Attribute,
-  RelationshipAttribute,
-} from "appwrite-utils";
-
-// Helper function to categorize collections based on relationship sides
-export const categorizeCollectionByRelationshipSide = (
-  attributes: Attribute[]
-): "parent" | "mixed" | "child" => {
-  let hasParent = false;
-  let hasChild = false;
-
-  for (const attr of attributes) {
-    if (attr.type === "relationship") {
-      if (attr.side === "parent") {
-        hasParent = true;
-      } else if (attr.side === "child") {
-        hasChild = true;
-      }
-    }
-  }
-
-  if (hasParent && hasChild) return "mixed";
-  if (hasParent) return "parent";
-  return "child";
-};
-
-// Helper function to get all dependencies of a collection
-export const getDependencies = (attributes: Attribute[]): string[] => {
-  return attributes
-    .filter(
-      (attr) =>
-        attr.type === "relationship" && attr.relatedCollection !== undefined
-    )
-    .map((attr) => (attr as RelationshipAttribute).relatedCollection);
-};
-
-// Function to sort collections based on dependencies and relationship sides
-export const sortCollections = (
-  configCollections: AppwriteConfig["collections"]
-): AppwriteConfig["collections"] => {
-  if (!configCollections) {
-    return [];
-  }
-  // Categorize collections based on their relationship sides
-  const parentCollections = configCollections.filter(
-    ({ attributes }) =>
-      categorizeCollectionByRelationshipSide(attributes) === "parent"
-  );
-  const mixedCollections = configCollections.filter(
-    ({ attributes }) =>
-      categorizeCollectionByRelationshipSide(attributes) === "mixed"
-  );
-  const childCollections = configCollections.filter(
-    ({ attributes }) =>
-      categorizeCollectionByRelationshipSide(attributes) === "child"
-  );
-
-  // Sort mixedCollections to ensure parents are processed before children within the mixed category
-  // This might involve more sophisticated logic if you need to order mixed collections based on specific parent-child relationships
-  mixedCollections.sort((a, b) => {
-    // Example sorting logic for mixed collections; adjust based on your specific needs
-    const aDependencies = getDependencies(a.attributes).length;
-    const bDependencies = getDependencies(b.attributes).length;
-    return aDependencies - bDependencies;
-  });
-
-  // Combine them back into a single array with the desired order
-  // Children first because they have no dependencies and parents will create the relationship if it's twoWay
-  return [...childCollections, ...parentCollections, ...mixedCollections];
-};
-
-// Function to sort attributes within a collection based on relationship sides
-export const sortAttributesByRelationshipSide = (
-  attributes: Attribute[]
-): Attribute[] => {
-  // Separate attributes into parent and child based on their relationship side
-  const parentAttributes = attributes.filter(
-    (attr) => attr.type === "relationship" && attr.side === "parent"
-  );
-  const childAttributes = attributes.filter(
-    (attr) => attr.type === "relationship" && attr.side === "child"
-  );
-  const otherAttributes = attributes.filter(
-    (attr) => attr.type !== "relationship"
-  );
-
-  // Combine them back into a single array with child attributes first, then other attributes, and parent attributes last
-  // as parent attributes will create the relationship with the child if needed
-  return [...childAttributes, ...otherAttributes, ...parentAttributes];
-};

package/src/migrations/indexes.ts

@@ -1,40 +0,0 @@
-import { indexSchema, type Index } from "appwrite-utils";
-import { Databases, IndexType, Query, type Models } from "node-appwrite";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-// import {}
-
-export const createOrUpdateIndex = async (
-  dbId: string,
-  db: Databases,
-  collectionId: string,
-  index: Index
-) => {
-  const existingIndex = await db.listIndexes(dbId, collectionId, [
-    Query.equal("key", index.key),
-  ]);
-  if (existingIndex.total > 0) {
-    await db.deleteIndex(dbId, collectionId, existingIndex.indexes[0].key);
-  }
-  const newIndex = await db.createIndex(
-    dbId,
-    collectionId,
-    index.key,
-    index.type as IndexType,
-    index.attributes,
-    index.orders
-  );
-  return newIndex;
-};
-
-export const createOrUpdateIndexes = async (
-  dbId: string,
-  db: Databases,
-  collectionId: string,
-  indexes: Index[]
-) => {
-  for (const index of indexes) {
-    await tryAwaitWithRetry(
-      async () => await createOrUpdateIndex(dbId, db, collectionId, index)
-    );
-  }
-};

package/src/migrations/logging.ts

@@ -1,29 +0,0 @@
-import winston from "winston";
-import fs from "fs";
-import path from "path";
-
-// Ensure the logs directory exists
-const logDir = path.join(process.cwd(), "zlogs");
-if (!fs.existsSync(logDir)) {
-  fs.mkdirSync(logDir);
-}
-
-export const logger = winston.createLogger({
-  level: "debug",
-  format: winston.format.json({ space: 2 }),
-  defaultMeta: { service: "appwrite-utils-cli" },
-  transports: [
-    new winston.transports.File({
-      filename: path.join(logDir, "error.log"),
-      level: "error",
-    }),
-    new winston.transports.File({
-      filename: path.join(logDir, "warn.log"),
-      level: "warn",
-    }),
-    new winston.transports.File({
-      filename: path.join(logDir, "info.log"),
-      level: "info",
-    }),
-  ],
-});