appwrite-utils-cli 1.7.8 → 1.8.1

package/dist/utils/schemaStrings.js

@@ -1,428 +0,0 @@
-import { toCamelCase, toPascalCase } from "../utils/index.js";
-import { Databases } from "node-appwrite";
-import { z } from "zod";
-import fs from "fs";
-import path from "path";
-import { dump } from "js-yaml";
-import { findFunctionsDir } from "./loadConfigs.js";
-import { ulid } from "ulidx";
-export class SchemaGenerator {
-    relationshipMap = new Map();
-    config;
-    appwriteFolderPath;
-    constructor(config, appwriteFolderPath) {
-        this.config = config;
-        this.appwriteFolderPath = appwriteFolderPath;
-        this.extractRelationships();
-    }
-    resolveCollectionName = (idOrName) => {
-        const col = this.config.collections?.find((c) => c.$id === idOrName || c.name === idOrName);
-        return col?.name ?? idOrName;
-    };
-    updateTsSchemas() {
-        const collections = this.config.collections;
-        const functions = this.config.functions || [];
-        delete this.config.collections;
-        delete this.config.functions;
-        const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
-        const configContent = `import { type AppwriteConfig } from "appwrite-utils";
-  
-  const appwriteConfig: AppwriteConfig = {
-    appwriteEndpoint: "${this.config.appwriteEndpoint}",
-    appwriteProject: "${this.config.appwriteProject}",
-    appwriteKey: "${this.config.appwriteKey}",
-    enableBackups: ${this.config.enableBackups},
-    backupInterval: ${this.config.backupInterval},
-    backupRetention: ${this.config.backupRetention},
-    enableBackupCleanup: ${this.config.enableBackupCleanup},
-    enableMockData: ${this.config.enableMockData},
-    documentBucketId: "${this.config.documentBucketId}",
-    usersCollectionName: "${this.config.usersCollectionName}",
-    databases: ${JSON.stringify(this.config.databases)},
-    buckets: ${JSON.stringify(this.config.buckets)},
-    functions: ${JSON.stringify(functions.map((func) => ({
-            functionId: func.$id || ulid(),
-            name: func.name,
-            runtime: func.runtime,
-            path: func.dirPath || `functions/${func.name}`,
-            entrypoint: func.entrypoint || "src/index.ts",
-            execute: func.execute,
-            events: func.events || [],
-            schedule: func.schedule || "",
-            timeout: func.timeout || 15,
-            enabled: func.enabled !== false,
-            logging: func.logging !== false,
-            commands: func.commands || "npm install",
-            scopes: func.scopes || [],
-            installationId: func.installationId,
-            providerRepositoryId: func.providerRepositoryId,
-            providerBranch: func.providerBranch,
-            providerSilentMode: func.providerSilentMode,
-            providerRootDirectory: func.providerRootDirectory,
-            specification: func.specification,
-            ...(func.predeployCommands
-                ? { predeployCommands: func.predeployCommands }
-                : {}),
-            ...(func.deployDir ? { deployDir: func.deployDir } : {}),
-        })), null, 2)}
-  };
-  
-  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 { type 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
-                        if (value.length > 0) {
-                            return `${key}: [${value
-                                .map((item) => `"${item}"`)
-                                .join(", ")}]`;
-                        }
-                        else {
-                            return `${key}: []`;
-                        }
-                    }
-                    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}], orders: [${index.orders
-                    ?.filter((order) => order !== null)
-                    .map((order) => `"${order}"`)
-                    .join(", ") ?? ""}] }`;
-            }) ?? []).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) => {
-            if (!collection.attributes) {
-                return;
-            }
-            collection.attributes.forEach((attr) => {
-                if (attr.type === "relationship" && attr.twoWay && attr.twoWayKey) {
-                    const relationshipAttr = attr;
-                    let isArrayParent = false;
-                    let isArrayChild = false;
-                    switch (relationshipAttr.relationType) {
-                        case "oneToMany":
-                            isArrayParent = true;
-                            isArrayChild = false;
-                            break;
-                        case "manyToMany":
-                            isArrayParent = true;
-                            isArrayChild = true;
-                            break;
-                        case "oneToOne":
-                            isArrayParent = false;
-                            isArrayChild = false;
-                            break;
-                        case "manyToOne":
-                            isArrayParent = false;
-                            isArrayChild = true;
-                            break;
-                        default:
-                            break;
-                    }
-                    this.addRelationship(collection.name, this.resolveCollectionName(relationshipAttr.relatedCollection), attr.key, relationshipAttr.twoWayKey, isArrayParent, isArrayChild);
-                    console.log(`Extracted relationship: ${attr.key}\n\t${collection.name} -> ${relationshipAttr.relatedCollection}, databaseId: ${collection.databaseId}`);
-                }
-            });
-        });
-    }
-    addRelationship(parentCollection, childCollection, parentKey, childKey, isArrayParent, isArrayChild) {
-        const relationshipsChild = this.relationshipMap.get(childCollection) || [];
-        const relationshipsParent = this.relationshipMap.get(parentCollection) || [];
-        relationshipsParent.push({
-            parentCollection,
-            childCollection,
-            parentKey,
-            childKey,
-            isArray: isArrayParent,
-            isChild: false,
-        });
-        relationshipsChild.push({
-            parentCollection,
-            childCollection,
-            parentKey,
-            childKey,
-            isArray: isArrayChild,
-            isChild: true,
-        });
-        this.relationshipMap.set(childCollection, relationshipsChild);
-        this.relationshipMap.set(parentCollection, relationshipsParent);
-    }
-    generateSchemas() {
-        if (!this.config.collections) {
-            return;
-        }
-        this.config.collections.forEach((collection) => {
-            const schemaString = this.createSchemaStringV4(collection.name, collection.attributes);
-            const camelCaseName = toCamelCase(collection.name);
-            const schemaPath = path.join(this.appwriteFolderPath, "schemas", `${camelCaseName}.ts`);
-            fs.writeFileSync(schemaPath, schemaString, { encoding: "utf-8" });
-            console.log(`Schema written to ${schemaPath}`);
-        });
-    }
-    // Zod v4 recursive getter-based schemas
-    createSchemaStringV4 = (name, attributes) => {
-        const pascalName = toPascalCase(name);
-        let imports = `import { z } from "zod";\n`;
-        // Use the relationshipMap to find related collections
-        const relationshipDetails = this.relationshipMap.get(name) || [];
-        let relatedCollections = relationshipDetails
-            .filter((detail, index, self) => {
-            const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
-            return (index ===
-                self.findIndex((obj) => `${obj.parentCollection}-${obj.childCollection}-${obj.parentKey}-${obj.childKey}` ===
-                    uniqueKey));
-        })
-            .map((detail) => {
-            const relatedCollectionName = detail.isChild
-                ? detail.parentCollection
-                : detail.childCollection;
-            const key = detail.isChild ? detail.childKey : detail.parentKey;
-            const isArray = detail.isArray ? "array" : "";
-            return [relatedCollectionName, key, isArray];
-        });
-        // Include one-way relationship attributes directly (no twoWayKey)
-        const oneWayRels = [];
-        for (const attr of attributes) {
-            if (attr.type === "relationship" && attr.relatedCollection) {
-                const relatedName = this.resolveCollectionName(attr.relatedCollection);
-                const isArray = attr.relationType === "oneToMany" || attr.relationType === "manyToMany"
-                    ? "array"
-                    : "";
-                oneWayRels.push([relatedName, attr.key, isArray]);
-            }
-        }
-        // Merge and dedupe (by relatedName+key)
-        relatedCollections = [...relatedCollections, ...oneWayRels].filter((item, idx, self) => idx === self.findIndex((o) => `${o[0]}::${o[1]}` === `${item[0]}::${item[1]}`));
-        const hasRelationships = relatedCollections.length > 0;
-        // Build imports for related collections
-        if (hasRelationships) {
-            const importLines = relatedCollections.map((rel) => {
-                const relatedPascalName = toPascalCase(rel[0]);
-                const relatedCamelName = toCamelCase(rel[0]);
-                return `import { ${relatedPascalName}Schema } from "./${relatedCamelName}";`;
-            });
-            const unique = Array.from(new Set(importLines));
-            imports += unique.join("\n") + (unique.length ? "\n" : "");
-        }
-        let schemaString = `${imports}\n`;
-        // Single object schema with recursive getters (Zod v4)
-        schemaString += `export const ${pascalName}Schema = z.object({\n`;
-        schemaString += `  $id: z.string(),\n`;
-        schemaString += `  $createdAt: z.string(),\n`;
-        schemaString += `  $updatedAt: z.string(),\n`;
-        schemaString += `  $permissions: z.array(z.string()),\n`;
-        for (const attribute of attributes) {
-            if (attribute.type === "relationship")
-                continue;
-            schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
-        }
-        // Add recursive getters for relationships (respect required flag)
-        relatedCollections.forEach((rel) => {
-            const relatedPascalName = toPascalCase(rel[0]);
-            const isArray = rel[2] === "array";
-            const key = String(rel[1]);
-            const attrMeta = attributes.find(a => a.key === key && a.type === "relationship");
-            const isRequired = !!attrMeta?.required;
-            let getterBody = "";
-            if (isArray) {
-                getterBody = isRequired
-                    ? `${relatedPascalName}Schema.array()`
-                    : `${relatedPascalName}Schema.array().nullish()`;
-            }
-            else {
-                getterBody = isRequired
-                    ? `${relatedPascalName}Schema`
-                    : `${relatedPascalName}Schema.nullish()`;
-            }
-            schemaString += `  get ${key}(){\n    return ${getterBody}\n  },\n`;
-        });
-        schemaString += `});\n\n`;
-        schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
-        return schemaString;
-    };
-    typeToZod = (attribute) => {
-        let baseSchemaCode = "";
-        const finalAttribute = (attribute.type === "string" &&
-            attribute.format &&
-            attribute.format === "enum" &&
-            attribute.type === "string"
-            ? { ...attribute, type: attribute.format }
-            : attribute);
-        switch (finalAttribute.type) {
-            case "string":
-                baseSchemaCode = "z.string()";
-                if (finalAttribute.size) {
-                    baseSchemaCode += `.max(${finalAttribute.size}, "Maximum length of ${finalAttribute.size} characters exceeded")`;
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!attribute.required && !attribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "integer":
-                baseSchemaCode = "z.number().int()";
-                if (finalAttribute.min !== undefined) {
-                    if (BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
-                        finalAttribute.min = undefined;
-                    }
-                    else {
-                        baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
-                    }
-                }
-                if (finalAttribute.max !== undefined) {
-                    if (BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
-                        finalAttribute.max = undefined;
-                    }
-                    else {
-                        baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
-                    }
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "double":
-            case "float": // Backward compatibility
-                baseSchemaCode = "z.number()";
-                if (finalAttribute.min !== undefined) {
-                    baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
-                }
-                if (finalAttribute.max !== undefined) {
-                    baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "boolean":
-                baseSchemaCode = "z.boolean()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "datetime":
-                baseSchemaCode = "z.date()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(new Date("${finalAttribute.xdefault}"))`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "email":
-                baseSchemaCode = "z.string().email()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "ip":
-                baseSchemaCode = "z.string()"; // Add custom validation as needed
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "url":
-                baseSchemaCode = "z.string().url()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "enum":
-                baseSchemaCode = `z.enum([${finalAttribute.elements
-                    .map((element) => `"${element}"`)
-                    .join(", ")}])`;
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!attribute.required && !attribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "relationship":
-                break;
-            default:
-                baseSchemaCode = "z.any()";
-        }
-        // Handle arrays
-        if (attribute.array) {
-            baseSchemaCode = `z.array(${baseSchemaCode})`;
-        }
-        if (attribute.array && !attribute.required) {
-            baseSchemaCode += ".nullish()";
-        }
-        return baseSchemaCode;
-    };
-}