appwrite-utils-cli 1.3.5 → 1.4.0

package/dist/migrations/converters.js

@@ -1,139 +0,0 @@
-import { converterFunctions } from "appwrite-utils";
-import { cloneDeep, isPlainObject } from "es-toolkit";
-/**
- * Deeply converts all properties of an object (or array) to strings.
- * @param data The input data to convert.
- * @returns The data with all its properties converted to strings.
- */
-export const deepAnyToString = (data) => {
-    if (Array.isArray(data)) {
-        return data.map((item) => deepAnyToString(item));
-    }
-    else if (isPlainObject(data)) {
-        return Object.keys(data).reduce((acc, key) => {
-            acc[key] = deepAnyToString(data[key]);
-            return acc;
-        }, {});
-    }
-    else {
-        return converterFunctions.anyToString(data);
-    }
-};
-/**
- * Performs a deep conversion of all values in a nested structure to the specified type.
- * Uses a conversion function like anyToString, anyToNumber, etc.
- * @param data The data to convert.
- * @param convertFn The conversion function to apply.
- * @returns The converted data.
- */
-export const deepConvert = (data, convertFn) => {
-    if (Array.isArray(data)) {
-        return data.map((item) => deepConvert(item, convertFn));
-    }
-    else if (isPlainObject(data)) {
-        return Object.keys(data).reduce((acc, key) => {
-            acc[key] = deepConvert(data[key], convertFn);
-            return acc;
-        }, {});
-    }
-    else {
-        return convertFn(data);
-    }
-};
-/**
- * Converts an entire object's properties to different types based on a provided schema.
- * @param obj The object to convert.
- * @param schema A mapping of object keys to conversion functions.
- * @returns The converted object.
- */
-export const convertObjectBySchema = (obj, schema) => {
-    return Object.keys(obj).reduce((acc, key) => {
-        const convertFn = schema[key];
-        acc[key] = convertFn ? convertFn(obj[key]) : obj[key];
-        return acc;
-    }, {});
-};
-/**
- * Converts the keys of an object based on a provided attributeMappings.
- * Each key in the object is checked against attributeMappings; if a matching entry is found,
- * the key is renamed to the targetKey specified in attributeMappings.
- *
- * @param obj The object to convert.
- * @param attributeMappings The attributeMappings defining how keys in the object should be converted.
- * @returns The converted object with keys renamed according to attributeMappings.
- */
-export const convertObjectByAttributeMappings = (obj, attributeMappings) => {
-    const result = {};
-    // Correctly handle [any] notation by mapping or aggregating over all elements or keys
-    const resolveValue = (obj, path) => {
-        const parts = path.split(".");
-        let current = obj;
-        for (let i = 0; i < parts.length; i++) {
-            if (parts[i] === "[any]") {
-                if (Array.isArray(current)) {
-                    // If current is an array, apply resolution to each item
-                    return current.map((item) => resolveValue(item, parts.slice(i + 1).join(".")));
-                }
-                else if (typeof current === "object" && current !== null) {
-                    // If current is an object, aggregate values from all keys
-                    return Object.values(current).map((value) => resolveValue(value, parts.slice(i + 1).join(".")));
-                }
-            }
-            else {
-                current = current[parts[i]];
-                if (current === undefined)
-                    return undefined;
-            }
-        }
-        return current;
-    };
-    for (const mapping of attributeMappings) {
-        if (mapping.valueToSet !== undefined) {
-            result[mapping.targetKey] = mapping.valueToSet;
-        }
-        else if (Array.isArray(mapping.oldKeys)) {
-            // Collect and flatten values from multiple oldKeys
-            const values = mapping.oldKeys
-                .map((oldKey) => resolveValue(obj, oldKey))
-                .flat(Infinity);
-            if (values.length > 0) {
-                result[mapping.targetKey] = values.filter((value) => value !== undefined);
-            }
-            else {
-                result[mapping.targetKey] = null;
-            }
-        }
-        else if (mapping.oldKey) {
-            // Resolve single oldKey
-            const value = resolveValue(obj, mapping.oldKey);
-            if (value !== undefined) {
-                result[mapping.targetKey] = Array.isArray(value)
-                    ? value.flat(Infinity)
-                    : value;
-            }
-            else {
-                result[mapping.targetKey] = value ? value : null;
-            }
-        }
-    }
-    return result;
-};
-/**
- * Ensures data conversion without mutating the original input.
- * @param data The data to convert.
- * @param convertFn The conversion function to apply.
- * @returns The converted data.
- */
-export const immutableConvert = (data, convertFn) => {
-    const clonedData = cloneDeep(data);
-    return convertFn(clonedData);
-};
-/**
- * Validates a string against a regular expression and returns the string if valid, or null.
- * @param value The string to validate.
- * @param pattern The regex pattern to validate against.
- * @returns The original string if valid, otherwise null.
- */
-export const validateString = (value, pattern) => {
-    return pattern.test(value) ? value : null;
-};

package/dist/migrations/databases.d.ts

@@ -1,2 +0,0 @@
-import { Databases, type Models } from "node-appwrite";
-export declare const fetchAllDatabases: (database: Databases) => Promise<Models.Database[]>;

package/dist/migrations/databases.js

@@ -1,28 +0,0 @@
-import { Client, Databases, IndexType, Query, } from "node-appwrite";
-import { getAppwriteClient, tryAwaitWithRetry, } from "../utils/helperFunctions.js";
-export const fetchAllDatabases = async (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/dist/migrations/dbHelpers.d.ts

@@ -1,5 +0,0 @@
-import type { AppwriteConfig, Attribute } from "appwrite-utils";
-export declare const categorizeCollectionByRelationshipSide: (attributes: Attribute[]) => "parent" | "mixed" | "child";
-export declare const getDependencies: (attributes: Attribute[]) => string[];
-export declare const sortCollections: (configCollections: AppwriteConfig["collections"]) => AppwriteConfig["collections"];
-export declare const sortAttributesByRelationshipSide: (attributes: Attribute[]) => Attribute[];

package/dist/migrations/dbHelpers.js

@@ -1,57 +0,0 @@
-// Helper function to categorize collections based on relationship sides
-export const categorizeCollectionByRelationshipSide = (attributes) => {
-    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) => {
-    return attributes
-        .filter((attr) => attr.type === "relationship" && attr.relatedCollection !== undefined)
-        .map((attr) => attr.relatedCollection);
-};
-// Function to sort collections based on dependencies and relationship sides
-export const sortCollections = (configCollections) => {
-    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) => {
-    // 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/dist/migrations/helper.d.ts

@@ -1,3 +0,0 @@
-import type { Databases, Models } from "node-appwrite";
-import type { OperationCreate } from "../storage/schemas.js";
-export declare const logOperation: (db: Databases, dbId: string, operationDetails: OperationCreate, operationId?: string) => Promise<Models.Document>;

package/dist/migrations/helper.js

@@ -1,21 +0,0 @@
-import { tryAwaitWithRetry } from "appwrite-utils";
-import { ulid } from "ulidx";
-export const logOperation = async (db, dbId, operationDetails, operationId) => {
-    try {
-        let operation;
-        if (operationId) {
-            // Update existing operation log
-            operation = await tryAwaitWithRetry(async () => await db.updateDocument("migrations", "currentOperations", operationId, operationDetails));
-        }
-        else {
-            // Create new operation log
-            operation = await db.createDocument("migrations", "currentOperations", ulid(), operationDetails);
-        }
-        console.log(`Operation logged: ${operation.$id}`);
-        return operation;
-    }
-    catch (error) {
-        console.error(`Error logging operation: ${error}`);
-        throw error;
-    }
-};

package/dist/migrations/indexes.d.ts

@@ -1,4 +0,0 @@
-import { type Index } from "appwrite-utils";
-import { Databases, type Models } from "node-appwrite";
-export declare const createOrUpdateIndex: (dbId: string, db: Databases, collectionId: string, index: Index) => Promise<Models.Index>;
-export declare const createOrUpdateIndexes: (dbId: string, db: Databases, collectionId: string, indexes: Index[]) => Promise<void>;

package/dist/migrations/indexes.js

@@ -1,19 +0,0 @@
-import { indexSchema } from "appwrite-utils";
-import { Databases, IndexType, Query } from "node-appwrite";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-// import {}
-export const createOrUpdateIndex = async (dbId, db, collectionId, 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, index.attributes, index.orders);
-    return newIndex;
-};
-export const createOrUpdateIndexes = async (dbId, db, collectionId, indexes) => {
-    for (const index of indexes) {
-        await tryAwaitWithRetry(async () => await createOrUpdateIndex(dbId, db, collectionId, index));
-    }
-};

package/dist/migrations/logging.d.ts

@@ -1,10 +0,0 @@
-import winston from "winston";
-export interface LoggingConfig {
-    enabled: boolean;
-    level: string;
-    logDirectory?: string;
-    console: boolean;
-}
-export declare const configureLogging: (config?: Partial<LoggingConfig>) => void;
-export declare let logger: winston.Logger;
-export declare const updateLogger: () => void;

package/dist/migrations/logging.js

@@ -1,46 +0,0 @@
-import winston from "winston";
-import fs from "fs";
-import path from "path";
-const DEFAULT_LOGGING_CONFIG = {
-    enabled: false,
-    level: "info",
-    console: false,
-};
-let loggingConfig = DEFAULT_LOGGING_CONFIG;
-export const configureLogging = (config = {}) => {
-    loggingConfig = { ...DEFAULT_LOGGING_CONFIG, ...config };
-};
-const createLogger = () => {
-    const transports = [];
-    // Add console transport if enabled
-    if (loggingConfig.console) {
-        transports.push(new winston.transports.Console({
-            format: winston.format.combine(winston.format.colorize(), winston.format.simple())
-        }));
-    }
-    // Add file transports if logging is enabled
-    if (loggingConfig.enabled) {
-        const logDir = loggingConfig.logDirectory || path.join(process.cwd(), "zlogs");
-        if (!fs.existsSync(logDir)) {
-            fs.mkdirSync(logDir, { recursive: true });
-        }
-        transports.push(new winston.transports.File({
-            filename: path.join(logDir, "error.log"),
-            level: "error",
-        }), new winston.transports.File({
-            filename: path.join(logDir, "combined.log"),
-        }));
-    }
-    return winston.createLogger({
-        level: loggingConfig.level,
-        format: winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json()),
-        defaultMeta: { service: "appwrite-utils-cli" },
-        transports,
-        silent: !loggingConfig.enabled && !loggingConfig.console,
-    });
-};
-export let logger = createLogger();
-// Recreate logger when config changes
-export const updateLogger = () => {
-    logger = createLogger();
-};

package/dist/migrations/migrationHelper.d.ts

@@ -1,173 +0,0 @@
-import { type Databases } from "node-appwrite";
-import { z } from "zod";
-/**
- * Object that contains the context for an action that needs to be executed after import
- * Used in the afterImportActionsDefinitions
- * @type {ContextObject}
- * @typedef {Object} ContextObject
- * @property {string} collectionId - The ID of the collection
- * @property {any} finalItem - The final item that was imported
- * @property {string} action - The name of the action
- * @property {string[]} params - The parameters for the action
- * @property {Object} context - The context object for the action (all the data of this specific item)
- */
-export declare const ContextObject: z.ZodObject<{
-    dbId: z.ZodString;
-    collectionId: z.ZodString;
-    finalItem: z.ZodAny;
-    attributeMappings: z.ZodArray<z.ZodObject<{
-        oldKey: z.ZodOptional<z.ZodString>;
-        oldKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        targetKey: z.ZodString;
-        valueToSet: z.ZodOptional<z.ZodAny>;
-        fileData: z.ZodOptional<z.ZodObject<{
-            name: z.ZodString;
-            path: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            path: string;
-            name: string;
-        }, {
-            path: string;
-            name: string;
-        }>>;
-        converters: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
-        validationActions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
-            action: z.ZodString;
-            params: z.ZodArray<z.ZodString, "many">;
-        }, "strip", z.ZodTypeAny, {
-            params: string[];
-            action: string;
-        }, {
-            params: string[];
-            action: string;
-        }>, "many">>>;
-        postImportActions: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
-            action: z.ZodString;
-            params: z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>, "many">;
-        }, "strip", z.ZodTypeAny, {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }, {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }>, "many">>>;
-    }, "strip", z.ZodTypeAny, {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }, {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }>, "many">;
-    context: z.ZodAny;
-}, "strip", z.ZodTypeAny, {
-    collectionId: string;
-    attributeMappings: {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }[];
-    dbId: string;
-    context?: any;
-    finalItem?: any;
-}, {
-    collectionId: string;
-    attributeMappings: {
-        targetKey: string;
-        oldKey?: string | undefined;
-        oldKeys?: string[] | undefined;
-        valueToSet?: any;
-        fileData?: {
-            path: string;
-            name: string;
-        } | undefined;
-        converters?: string[] | undefined;
-        validationActions?: {
-            params: string[];
-            action: string;
-        }[] | undefined;
-        postImportActions?: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[] | undefined;
-    }[];
-    dbId: string;
-    context?: any;
-    finalItem?: any;
-}>;
-export type ContextObject = z.infer<typeof ContextObject>;
-export declare const createOrFindAfterImportOperation: (database: Databases, collectionId: string, context: ContextObject) => Promise<void>;
-export declare const addBatch: (database: Databases, data: string) => Promise<string>;
-export declare const getAfterImportOperations: (database: Databases, collectionId: string) => Promise<{
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    error: string;
-    $id: string;
-    $createdAt: string;
-    $updatedAt: string;
-    collectionId: string;
-    operationType: string;
-    progress: number;
-    total: number;
-    data?: any;
-    batches?: string[] | undefined;
-}[]>;
-export declare const findOrCreateOperation: (database: Databases, collectionId: string, operationType: string, additionalQueries?: string[]) => Promise<{
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
-    error: string;
-    $id: string;
-    $createdAt: string;
-    $updatedAt: string;
-    collectionId: string;
-    operationType: string;
-    progress: number;
-    total: number;
-    data?: any;
-    batches?: string[] | undefined;
-}>;
-export declare const updateOperation: (database: Databases, operationId: string, updateFields: any) => Promise<void>;
-export declare const maxDataLength = 1073741820;
-export declare const maxBatchItems = 25;
-export declare const splitIntoBatches: (data: any[]) => any[][];

package/dist/migrations/migrationHelper.js

@@ -1,130 +0,0 @@
-import { ID, Query } from "node-appwrite";
-import { BatchSchema, OperationSchema } from "./backup.js";
-import { AttributeMappingsSchema } from "appwrite-utils";
-import { z } from "zod";
-import { logger } from "./logging.js";
-import { tryAwaitWithRetry } from "../utils/helperFunctions.js";
-/**
- * Object that contains the context for an action that needs to be executed after import
- * Used in the afterImportActionsDefinitions
- * @type {ContextObject}
- * @typedef {Object} ContextObject
- * @property {string} collectionId - The ID of the collection
- * @property {any} finalItem - The final item that was imported
- * @property {string} action - The name of the action
- * @property {string[]} params - The parameters for the action
- * @property {Object} context - The context object for the action (all the data of this specific item)
- */
-export const ContextObject = z.object({
-    dbId: z.string(),
-    collectionId: z.string(),
-    finalItem: z.any(),
-    attributeMappings: AttributeMappingsSchema,
-    context: z.any(),
-});
-export const createOrFindAfterImportOperation = async (database, collectionId, context) => {
-    let operation = await findOrCreateOperation(database, collectionId, "afterImportAction");
-    if (!operation.batches) {
-        operation.batches = [];
-    }
-    // Directly create a new batch for the context without checking for an existing batch
-    const contextData = JSON.stringify(context);
-    // Create a new batch with the contextData
-    const newBatchId = await addBatch(database, contextData);
-    // Update the operation with the new batch's $id
-    operation.batches = [...operation.batches, newBatchId];
-    await database.updateDocument("migrations", "currentOperations", operation.$id, { batches: operation.batches });
-};
-export const addBatch = async (database, data) => {
-    const batch = await database.createDocument("migrations", "batches", ID.unique(), {
-        data,
-        processed: false,
-    });
-    return batch.$id;
-};
-export const getAfterImportOperations = async (database, collectionId) => {
-    let lastDocumentId;
-    const allOperations = [];
-    let total = 0;
-    do {
-        const query = [
-            Query.equal("collectionId", collectionId),
-            Query.equal("operationType", "afterImportAction"),
-            Query.limit(100),
-        ];
-        if (lastDocumentId) {
-            query.push(Query.cursorAfter(lastDocumentId));
-        }
-        const operations = await database.listDocuments("migrations", "currentOperations", query);
-        total = operations.total; // Update total with the latest fetch
-        allOperations.push(...operations.documents);
-        if (operations.documents.length > 0 && operations.documents.length >= 100) {
-            lastDocumentId =
-                operations.documents[operations.documents.length - 1].$id;
-        }
-    } while (allOperations.length < total);
-    const allOps = allOperations.map((op) => OperationSchema.parse(op));
-    return allOps;
-};
-export const findOrCreateOperation = async (database, collectionId, operationType, additionalQueries) => {
-    const operations = await tryAwaitWithRetry(async () => await database.listDocuments("migrations", "currentOperations", [
-        Query.equal("collectionId", collectionId),
-        Query.equal("operationType", operationType),
-        Query.equal("status", "pending"),
-        ...(additionalQueries || []),
-    ]));
-    if (operations.documents.length > 0) {
-        return OperationSchema.parse(operations.documents[0]); // Assuming the first document is the operation we want
-    }
-    else {
-        // Create a new operation document
-        const op = await tryAwaitWithRetry(async () => await database.createDocument("migrations", "currentOperations", ID.unique(), {
-            operationType,
-            collectionId,
-            status: "pending",
-            batches: [],
-            progress: 0,
-            total: 0,
-            error: "",
-        }));
-        return OperationSchema.parse(op);
-    }
-};
-export const updateOperation = async (database, operationId, updateFields) => {
-    await tryAwaitWithRetry(async () => await database.updateDocument("migrations", "currentOperations", operationId, updateFields));
-};
-// Actual max 1073741824
-export const maxDataLength = 1073741820;
-export const maxBatchItems = 25;
-export const splitIntoBatches = (data) => {
-    let batches = [];
-    let currentBatch = [];
-    let currentBatchLength = 0;
-    let currentBatchItemCount = 0;
-    data.forEach((item, index) => {
-        const itemLength = JSON.stringify(item).length;
-        if (itemLength > maxDataLength) {
-            console.log(item, `Large item found at index ${index} with length ${itemLength}:`);
-        }
-        // Check if adding the current item would exceed the max length or max items per batch
-        if (currentBatchLength + itemLength >= maxDataLength ||
-            currentBatchItemCount >= maxBatchItems) {
-            // If so, start a new batch
-            batches.push(currentBatch);
-            currentBatch = [item];
-            currentBatchLength = itemLength;
-            currentBatchItemCount = 1; // Reset item count for the new batch
-        }
-        else {
-            // Otherwise, add the item to the current batch
-            currentBatch.push(item);
-            currentBatchLength += itemLength;
-            currentBatchItemCount++;
-        }
-    });
-    // Don't forget to add the last batch if it's not empty
-    if (currentBatch.length > 0) {
-        batches.push(currentBatch);
-    }
-    return batches;
-};

package/dist/migrations/openapi.d.ts

@@ -1,4 +0,0 @@
-import { type AppwriteConfig } from "appwrite-utils";
-import { z } from "zod";
-export declare const generateOpenApi: (config: AppwriteConfig) => Promise<void>;
-export declare function transformTypeToOpenApi<T extends z.ZodTypeAny>(schema: T, description?: string | Record<string, any> | null | undefined): T;