appwrite-utils-cli 0.0.274 → 0.0.275

package/dist/migrations/dataLoader.js

@@ -1,4 +1,4 @@
-import { AttributeMappingsSchema, CollectionCreateSchema, importDefSchema, } from "./schema.js";
+import { AttributeMappingsSchema, CollectionCreateSchema, importDefSchema, } from "appwrite-utils";
 import path from "path";
 import fs from "fs";
 import { convertObjectByAttributeMappings } from "./converters.js";
@@ -165,6 +165,9 @@ export class DataLoader {
             if (db.$id !== dbId) {
                 continue;
             }
+            if (!this.config.collections) {
+                continue;
+            }
             for (let index = 0; index < this.config.collections.length; index++) {
                 const collectionConfig = this.config.collections[index];
                 let collection = CollectionCreateSchema.parse(collectionConfig);
@@ -222,6 +225,9 @@ export class DataLoader {
             if (db.$id !== dbId) {
                 continue;
             }
+            if (!this.config.collections) {
+                continue;
+            }
             // Iterate over the configured collections to process each
             for (const collectionConfig of this.config.collections) {
                 const collection = collectionConfig;
@@ -269,6 +275,9 @@ export class DataLoader {
     async dealWithMergedUsers() {
         const usersCollectionKey = this.getCollectionKey(this.config.usersCollectionName);
         const usersCollectionPrimaryKeyFields = new Set();
+        if (!this.config.collections) {
+            return;
+        }
         // Collect primary key fields from the users collection definitions
         this.config.collections.forEach((collection) => {
             if (this.getCollectionKey(collection.name) === usersCollectionKey) {
@@ -306,6 +315,9 @@ export class DataLoader {
         });
     }
     async updateOldReferencesForNew() {
+        if (!this.config.collections) {
+            return;
+        }
         for (const collectionConfig of this.config.collections) {
             const collectionKey = this.getCollectionKey(collectionConfig.name);
             const collectionData = this.importMap.get(collectionKey);
@@ -360,6 +372,9 @@ export class DataLoader {
         }
     }
     async updateReferencesInRelatedCollections() {
+        if (!this.config.collections) {
+            return;
+        }
         // Iterate over each collection configuration
         for (const collectionConfig of this.config.collections) {
             const collectionKey = this.getCollectionKey(collectionConfig.name);
@@ -839,6 +854,9 @@ export class DataLoader {
         }
     }
     updateReferencesBasedOnAttributeMappings() {
+        if (!this.config.collections) {
+            return;
+        }
         this.config.collections.forEach((collectionConfig) => {
             const collectionName = collectionConfig.name;
             const collectionData = this.importMap.get(this.getCollectionKey(collectionName));

package/dist/migrations/dbHelpers.d.ts

@@ -1,4 +1,4 @@
-import type { AppwriteConfig, Attribute } from "./schema.js";
+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"];

package/dist/migrations/dbHelpers.js

@@ -26,6 +26,9 @@ export const getDependencies = (attributes) => {
 };
 // 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");

package/dist/migrations/importController.d.ts

@@ -1,5 +1,5 @@
 import { type Databases, type Storage } from "node-appwrite";
-import type { AppwriteConfig, ConfigDatabase } from "./schema.js";
+import type { AppwriteConfig, ConfigDatabase } from "appwrite-utils";
 import type { ImportDataActions } from "./importDataActions.js";
 import type { SetupOptions } from "../utilsController.js";
 import { DataLoader } from "./dataLoader.js";

package/dist/migrations/importController.js

@@ -1,16 +1,10 @@
 import { ID, Query, } from "node-appwrite";
-import { checkForCollection } from "./collections.js";
-import path from "path";
-import fs from "fs";
-import { convertObjectByAttributeMappings } from "./converters.js";
 import _ from "lodash";
-import { documentExists } from "./collections.js";
 import { areCollectionNamesSame } from "../utils/index.js";
 import { resolveAndUpdateRelationships } from "./relationships.js";
-import { AuthUserCreateSchema } from "../types.js";
 import { UsersController } from "./users.js";
 import { logger } from "./logging.js";
-import { ContextObject, createOrFindAfterImportOperation, getAfterImportOperations, splitIntoBatches, updateOperation, } from "./migrationHelper.js";
+import { updateOperation } from "./migrationHelper.js";
 import { BatchSchema, OperationCreateSchema, OperationSchema, } from "./backup.js";
 import { DataLoader } from "./dataLoader.js";
 export class ImportController {
@@ -69,6 +63,9 @@ export class ImportController {
         }
     }
     async importCollections(db, dataLoader) {
+        if (!this.config.collections) {
+            return;
+        }
         for (const collection of this.config.collections) {
             let isUsersCollection = dataLoader.getCollectionKey(this.config.usersCollectionName) ===
                 dataLoader.getCollectionKey(collection.name);

package/dist/migrations/importDataActions.d.ts

@@ -1,9 +1,8 @@
 import { type Databases, type Storage } from "node-appwrite";
-import type { AppwriteConfig } from "./schema.js";
-import { type ValidationRules } from "./validationRules.js";
-import { type ConverterFunctions } from "./converters.js";
-import { type AfterImportActions } from "./afterImportActions.js";
-type AttributeMappings = AppwriteConfig["collections"][number]["importDefs"][number]["attributeMappings"];
+import type { AppwriteConfig } from "appwrite-utils";
+import { type ValidationRules, type AttributeMappings } from "appwrite-utils";
+import { type ConverterFunctions } from "appwrite-utils";
+import { type AfterImportActions } from "appwrite-utils";
 export declare class ImportDataActions {
     private db;
     private storage;
@@ -41,4 +40,3 @@ export declare class ImportDataActions {
         [key: string]: any;
     }, item: any): any;
 }
-export {};

package/dist/migrations/importDataActions.js

@@ -1,7 +1,9 @@
 import { ID, InputFile, Query, } from "node-appwrite";
-import { validationRules } from "./validationRules.js";
-import { converterFunctions, convertObjectBySchema, } from "./converters.js";
-import { afterImportActions, } from "./afterImportActions.js";
+import { validationRules, } from "appwrite-utils";
+import { converterFunctions } from "appwrite-utils";
+import { convertObjectBySchema } from "./converters.js";
+import {} from "appwrite-utils";
+import { afterImportActions } from "./afterImportActions.js";
 import { logger } from "./logging.js";
 export class ImportDataActions {
     db;
@@ -21,7 +23,7 @@ export class ImportDataActions {
     runConverterFunctions(item, attributeMappings) {
         const conversionSchema = attributeMappings.reduce((schema, mapping) => {
             schema[mapping.targetKey] = (originalValue) => {
-                return mapping.converters.reduce((value, converterName) => {
+                return mapping.converters?.reduce((value, converterName) => {
                     let shouldProcessAsArray = false;
                     if ((converterName.includes("[Arr]") ||
                         converterName.includes("[arr]")) &&

package/dist/migrations/indexes.d.ts

@@ -1,4 +1,4 @@
-import { type Index } from "./schema.js";
+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,4 +1,4 @@
-import { indexSchema } from "./schema.js";
+import { indexSchema } from "appwrite-utils";
 import { Databases, Query } from "node-appwrite";
 // import {}
 export const createOrUpdateIndex = async (dbId, db, collectionId, index) => {

package/dist/migrations/migrationHelper.d.ts

@@ -29,8 +29,8 @@ export declare const ContextObject: z.ZodObject<{
             path: string;
             name: string;
         }>>;
-        converters: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-        validationActions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        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, {
@@ -39,8 +39,8 @@ export declare const ContextObject: z.ZodObject<{
         }, {
             params: string[];
             action: string;
-        }>, "many">>;
-        postImportActions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        }>, "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, {
@@ -49,24 +49,24 @@ export declare const ContextObject: z.ZodObject<{
         }, {
             params: (string | Record<string, any>)[];
             action: string;
-        }>, "many">>;
+        }>, "many">>>;
     }, "strip", z.ZodTypeAny, {
         targetKey: string;
-        converters: string[];
-        validationActions: {
-            params: string[];
-            action: string;
-        }[];
-        postImportActions: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[];
         oldKey?: string | undefined;
         oldKeys?: string[] | undefined;
         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;
@@ -87,29 +87,31 @@ export declare const ContextObject: z.ZodObject<{
     }>, "many">;
     context: z.ZodAny;
 }, "strip", z.ZodTypeAny, {
+    collectionId: string;
+    dbId: string;
     attributeMappings: {
         targetKey: string;
-        converters: string[];
-        validationActions: {
-            params: string[];
-            action: string;
-        }[];
-        postImportActions: {
-            params: (string | Record<string, any>)[];
-            action: string;
-        }[];
         oldKey?: string | undefined;
         oldKeys?: string[] | undefined;
         fileData?: {
             path: string;
             name: string;
         } | undefined;
+        converters?: string[] | undefined;
+        validationActions?: {
+            params: string[];
+            action: string;
+        }[] | undefined;
+        postImportActions?: {
+            params: (string | Record<string, any>)[];
+            action: string;
+        }[] | undefined;
     }[];
-    collectionId: string;
-    dbId: string;
     finalItem?: any;
     context?: any;
 }, {
+    collectionId: string;
+    dbId: string;
     attributeMappings: {
         targetKey: string;
         oldKey?: string | undefined;
@@ -128,8 +130,6 @@ export declare const ContextObject: z.ZodObject<{
             action: string;
         }[] | undefined;
     }[];
-    collectionId: string;
-    dbId: string;
     finalItem?: any;
     context?: any;
 }>;
@@ -138,10 +138,10 @@ export declare const createOrFindAfterImportOperation: (database: Databases, col
 export declare const addBatch: (database: Databases, data: string) => Promise<string>;
 export declare const getAfterImportOperations: (database: Databases, collectionId: string) => Promise<{
     error: string;
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
     $id: string;
     $createdAt: string;
     $updatedAt: string;
+    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
     collectionId: string;
     operationType: string;
     progress: number;
@@ -151,10 +151,10 @@ export declare const getAfterImportOperations: (database: Databases, collectionI
 }[]>;
 export declare const findOrCreateOperation: (database: Databases, collectionId: string, operationType: string, additionalQueries?: string[]) => Promise<{
     error: string;
-    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
     $id: string;
     $createdAt: string;
     $updatedAt: string;
+    status: "error" | "pending" | "ready" | "in_progress" | "completed" | "cancelled";
     collectionId: string;
     operationType: string;
     progress: number;

package/dist/migrations/migrationHelper.js

@@ -1,6 +1,6 @@
 import { ID, Query } from "node-appwrite";
 import { BatchSchema, OperationSchema } from "./backup.js";
-import { AttributeMappingsSchema } from "./schema.js";
+import { AttributeMappingsSchema } from "appwrite-utils";
 import { z } from "zod";
 import { logger } from "./logging.js";
 /**

package/dist/migrations/openapi.d.ts

@@ -1,4 +1,4 @@
-import { type AppwriteConfig } from "./schema.js";
+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): z.infer<T>;

package/dist/migrations/openapi.js

@@ -1,9 +1,12 @@
 import { OpenAPIRegistry, OpenApiGeneratorV3, OpenApiGeneratorV31, } from "@asteasolutions/zod-to-openapi";
-import { attributeSchema, collectionSchema, } from "./schema.js";
+import { attributeSchema, collectionSchema, } from "appwrite-utils";
 import { z } from "zod";
 import { writeFileSync } from "fs";
 const registry = new OpenAPIRegistry();
 export const generateOpenApi = async (config) => {
+    if (!config.collections) {
+        return;
+    }
     for (const collection of config.collections) {
         // Transform and register each attribute schema
         const attributeSchemas = collection.attributes.map((attribute) => {

package/dist/migrations/queue.d.ts

@@ -1,5 +1,5 @@
 import { type Databases, type Models } from "node-appwrite";
-import type { Attribute } from "./schema.js";
+import type { Attribute } from "appwrite-utils";
 export interface QueuedOperation {
     type: "attribute";
     collectionId?: string;

package/dist/migrations/relationships.d.ts

@@ -1,13 +1,11 @@
 import { Databases } from "node-appwrite";
-import type { AppwriteConfig } from "./schema.js";
+import type { AppwriteConfig } from "appwrite-utils";
 /**
  * Finds collections that have defined relationship attributes.
  */
 export declare const findCollectionsWithRelationships: (config: AppwriteConfig) => Map<string, {
-    key: string;
     type: "relationship";
-    error: string;
-    required: boolean;
+    key: string;
     relatedCollection: string;
     relationType: "oneToMany" | "manyToOne" | "oneToOne" | "manyToMany";
     twoWay: boolean;
@@ -15,10 +13,12 @@ export declare const findCollectionsWithRelationships: (config: AppwriteConfig)
     onDelete: "setNull" | "cascade" | "restrict";
     side: "parent" | "child";
     array?: boolean | undefined;
+    error?: string | undefined;
+    required?: boolean | undefined;
+    description?: string | Record<string, string> | null | undefined;
     importMapping?: {
         originalIdField: string;
         targetField?: string | undefined;
     } | undefined;
-    description?: string | Record<string, string> | null | undefined;
 }[]>;
 export declare function resolveAndUpdateRelationships(dbId: string, database: Databases, config: AppwriteConfig): Promise<void>;

package/dist/migrations/relationships.js

@@ -6,6 +6,9 @@ import { logger } from "./logging.js";
  */
 export const findCollectionsWithRelationships = (config) => {
     const toReturn = new Map();
+    if (!config.collections) {
+        return toReturn;
+    }
     for (const collection of config.collections) {
         if (collection.attributes) {
             for (const attribute of collection.attributes) {

package/dist/migrations/schemaStrings.d.ts

@@ -1,10 +1,10 @@
-import type { AppwriteConfig, Attribute } from "./schema.js";
+import type { AppwriteConfig, Attribute } from "appwrite-utils";
 export declare class SchemaGenerator {
     private relationshipMap;
     private config;
     private appwriteFolderPath;
     constructor(config: AppwriteConfig, appwriteFolderPath: string);
-    updateYamlSchemas(): void;
+    updateTsSchemas(): void;
     private extractRelationships;
     private addRelationship;
     generateSchemas(): void;

package/dist/migrations/schemaStrings.js

@@ -13,16 +13,98 @@ export class SchemaGenerator {
         this.appwriteFolderPath = appwriteFolderPath;
         this.extractRelationships();
     }
-    updateYamlSchemas() {
-        // Output this.config to a YAML file at appwriteFolderPath/appwriteConfig.yaml
-        let finalConfig = this.config;
-        finalConfig.appwriteClient = null;
-        const yamlConfig = finalConfig;
-        const yamlPath = path.join(this.appwriteFolderPath, "appwriteConfig.yaml");
-        fs.writeFileSync(yamlPath, dump(yamlConfig), { encoding: "utf-8" });
-        console.log(`YAML written to ${yamlPath}`);
+    updateTsSchemas() {
+        const collections = this.config.collections;
+        delete this.config.collections;
+        const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
+        const configContent = `import { AppwriteConfig } from "appwrite-utils";
+  
+  const appwriteConfig: AppwriteConfig = {
+    appwriteEndpoint: "${this.config.appwriteEndpoint}",
+    appwriteProject: "${this.config.appwriteProject}",
+    appwriteKey: "${this.config.appwriteKey}",
+    enableDevDatabase: ${this.config.enableDevDatabase},
+    enableBackups: ${this.config.enableBackups},
+    backupInterval: ${this.config.backupInterval},
+    backupRetention: ${this.config.backupRetention},
+    enableBackupCleanup: ${this.config.enableBackupCleanup},
+    enableMockData: ${this.config.enableMockData},
+    enableWipeOtherDatabases: ${this.config.enableWipeOtherDatabases},
+    documentBucketId: "${this.config.documentBucketId}",
+    usersCollectionName: "${this.config.usersCollectionName}",
+    databases: ${JSON.stringify(this.config.databases)}
+  };
+  
+  export default appwriteConfig;
+  `;
+        fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
+        const collectionsFolderPath = path.join(this.appwriteFolderPath, "collections");
+        if (!fs.existsSync(collectionsFolderPath)) {
+            fs.mkdirSync(collectionsFolderPath, { recursive: true });
+        }
+        collections?.forEach((collection) => {
+            const { databaseId, ...collectionWithoutDbId } = collection; // Destructure to exclude databaseId
+            const collectionFilePath = path.join(collectionsFolderPath, `${collection.name}.ts`);
+            const collectionContent = `import { CollectionCreate } from "appwrite-utils";
+  
+  const ${collection.name}Config: Partial<CollectionCreate> = {
+    name: "${collection.name}",
+    $id: "${collection.$id}",
+    enabled: ${collection.enabled},
+    documentSecurity: ${collection.documentSecurity},
+    $permissions: [
+      ${collection.$permissions
+                .map((permission) => `{ permission: "${permission.permission}", target: "${permission.target}" }`)
+                .join(",\n    ")}
+    ],
+    attributes: [
+      ${collection.attributes
+                .map((attr) => {
+                return `{ ${Object.entries(attr)
+                    .map(([key, value]) => {
+                    // Check the type of the value and format it accordingly
+                    if (typeof value === "string") {
+                        // If the value is a string, wrap it in quotes
+                        return `${key}: "${value.replace(/"/g, '\\"')}"`; // Escape existing quotes in the string
+                    }
+                    else if (Array.isArray(value)) {
+                        // If the value is an array, join it with commas
+                        return `${key}: [${value
+                            .map((item) => `"${item}"`)
+                            .join(", ")}]`;
+                    }
+                    else {
+                        // If the value is not a string (e.g., boolean or number), output it directly
+                        return `${key}: ${value}`;
+                    }
+                })
+                    .join(", ")} }`;
+            })
+                .join(",\n    ")}
+    ],
+    indexes: [
+      ${(collection.indexes?.map((index) => {
+                // Map each attribute to ensure it is properly quoted
+                const formattedAttributes = index.attributes
+                    .map((attr) => `"${attr}"`)
+                    .join(", ");
+                return `{ key: "${index.key}", type: "${index.type}", attributes: [${formattedAttributes}] }`;
+            }) ?? []).join(",\n    ")}
+    ]
+  };
+  
+  export default ${collection.name}Config;
+  `;
+            fs.writeFileSync(collectionFilePath, collectionContent, {
+                encoding: "utf-8",
+            });
+            console.log(`Collection schema written to ${collectionFilePath}`);
+        });
     }
     extractRelationships() {
+        if (!this.config.collections) {
+            return;
+        }
         this.config.collections.forEach((collection) => {
             collection.attributes.forEach((attr) => {
                 if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
@@ -78,6 +160,9 @@ export class SchemaGenerator {
         this.relationshipMap.set(parentCollection, relationshipsParent);
     }
     generateSchemas() {
+        if (!this.config.collections) {
+            return;
+        }
         this.config.collections.forEach((collection) => {
             const schemaString = this.createSchemaString(collection.name, collection.attributes);
             const camelCaseName = toCamelCase(collection.name);

package/dist/migrations/setupDatabase.d.ts

@@ -1,5 +1,5 @@
 import { Databases, Storage } from "node-appwrite";
-import { type AppwriteConfig } from "./schema.js";
+import { type AppwriteConfig } from "appwrite-utils";
 import type { SetupOptions } from "../utilsController.js";
 export declare const setupMigrationDatabase: (config: AppwriteConfig) => Promise<void>;
 export declare const ensureDatabasesExist: (config: AppwriteConfig) => Promise<void>;

package/dist/migrations/setupDatabase.js

@@ -4,7 +4,7 @@ import { createOrUpdateCollections, generateSchemas, wipeDatabase, } from "./col
 import { getMigrationCollectionSchemas } from "./backup.js";
 import { areCollectionNamesSame, toCamelCase } from "../utils/index.js";
 import { backupDatabase, initOrGetBackupStorage, initOrGetDocumentStorage, wipeDocumentStorage, } from "./storage.js";
-import {} from "./schema.js";
+import {} from "appwrite-utils";
 import { nameToIdMapping } from "./queue.js";
 import { UsersController } from "./users.js";
 export const setupMigrationDatabase = async (config) => {

package/dist/migrations/storage.d.ts

@@ -1,6 +1,6 @@
 import { Storage, Databases, type Models } from "node-appwrite";
 import { type OperationCreate } from "./backup.js";
-import type { AppwriteConfig } from "./schema.js";
+import type { AppwriteConfig } from "appwrite-utils";
 export declare const logOperation: (db: Databases, dbId: string, operationDetails: OperationCreate, operationId?: string) => Promise<Models.Document>;
 export declare const initOrGetBackupStorage: (storage: Storage) => Promise<Models.Bucket>;
 export declare const initOrGetDocumentStorage: (storage: Storage, config: AppwriteConfig, dbName: string) => Promise<Models.Bucket | undefined>;

package/dist/migrations/users.d.ts

@@ -1,4 +1,4 @@
-import type { AppwriteConfig } from "./schema.js";
+import type { AppwriteConfig } from "appwrite-utils";
 import { Databases, type Models } from "node-appwrite";
 import { type AuthUserCreate } from "../schemas/authUser.js";
 export declare class UsersController {

package/dist/schemas/authUser.d.ts

@@ -28,35 +28,37 @@ export declare const AuthUserSchema: z.ZodObject<{
     labels?: string[] | undefined;
 }>;
 export type AuthUser = z.infer<typeof AuthUserSchema>;
-export declare const AuthUserCreateSchema: z.ZodObject<{
-    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+export declare const AuthUserCreateSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
+    $id: z.ZodString;
     $createdAt: z.ZodOptional<z.ZodString>;
     $updatedAt: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     prefs: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
     labels: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+}, "$id">, {
     userId: z.ZodOptional<z.ZodString>;
     password: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+}>, "strip", z.ZodTypeAny, {
     prefs: Record<string, string>;
     labels: string[];
-    name?: string | null | undefined;
-    email?: string | null | undefined;
     $createdAt?: string | undefined;
     $updatedAt?: string | undefined;
+    name?: string | null | undefined;
+    password?: string | undefined;
+    email?: string | null | undefined;
     phone?: string | null | undefined;
     userId?: string | undefined;
-    password?: string | undefined;
 }, {
-    name?: string | null | undefined;
-    email?: string | null | undefined;
     $createdAt?: string | undefined;
     $updatedAt?: string | undefined;
+    name?: string | null | undefined;
+    password?: string | undefined;
+    email?: string | null | undefined;
     phone?: string | null | undefined;
     prefs?: Record<string, string> | undefined;
     labels?: string[] | undefined;
     userId?: string | undefined;
-    password?: string | undefined;
 }>;
 export type AuthUserCreate = z.infer<typeof AuthUserCreateSchema>;

package/dist/types.d.ts

@@ -1,9 +1,4 @@
-export type { AppwriteConfig } from "./migrations/schema.js";
-export type { ConverterFunctions } from "./migrations/converters.js";
 export type { ValidationRules } from "./migrations/validationRules.js";
-export type { AfterImportActions } from "./migrations/afterImportActions.js";
 export { type AuthUserCreate, AuthUserCreateSchema, type AuthUser, AuthUserSchema, } from "./schemas/authUser.js";
-export { getFileViewUrl, getFileDownloadUrl } from "./utils/helperFunctions.js";
-export { converterFunctions } from "./migrations/converters.js";
 export { validationRules } from "./migrations/validationRules.js";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/types.js

@@ -1,5 +1,3 @@
 export { AuthUserCreateSchema, AuthUserSchema, } from "./schemas/authUser.js";
-export { getFileViewUrl, getFileDownloadUrl } from "./utils/helperFunctions.js";
-export { converterFunctions } from "./migrations/converters.js";
 export { validationRules } from "./migrations/validationRules.js";
 export { afterImportActions } from "./migrations/afterImportActions.js";

package/dist/utils/helperFunctions.d.ts

@@ -1,6 +1,5 @@
 import type { Models } from "node-appwrite";
-import type { CollectionImportData } from "src/migrations/dataLoader.js";
-import type { ConfigCollection } from "src/migrations/schema.js";
+import type { CollectionImportData } from "../migrations/dataLoader.js";
 export declare const toPascalCase: (str: string) => string;
 export declare const toCamelCase: (str: string) => string;
 export declare const ensureDirectoryExistence: (filePath: string) => true | undefined;
@@ -34,4 +33,4 @@ export declare const getFileViewUrl: (endpoint: string, projectId: string, bucke
  * @return {string} The complete download URL for the file.
  */
 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 const finalizeByAttributeMap: (appwriteFolderPath: string, collection: Collections, item: CollectionImportData["data"][number]) => Promise<any>;

package/dist/utils/loadConfigs.d.ts

@@ -0,0 +1,13 @@
+import { type AppwriteConfig } from "appwrite-utils";
+/**
+ * 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 declare const findAppwriteConfig: (dir: string) => string | 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 declare const loadConfig: (configDir: string) => Promise<AppwriteConfig>;