@njdamstra/appwrite-utils-cli 1.8.9

package/dist/shared/relationshipExtractor.js

@@ -0,0 +1,138 @@
+/**
+ * Helper function to resolve collection name from ID or name
+ * @param config - Appwrite configuration containing collections
+ * @param idOrName - Collection ID or name to resolve
+ * @returns Resolved collection name, or the original input if not found
+ */
+export function resolveCollectionName(config, idOrName) {
+    const col = config.collections?.find((c) => c.$id === idOrName || c.name === idOrName);
+    return col?.name ?? idOrName;
+}
+/**
+ * Determines if a relationship type results in an array
+ * @param relationType - The type of relationship (oneToOne, oneToMany, manyToOne, manyToMany)
+ * @returns true if the relationship results in an array
+ */
+export function isArrayRelationship(relationType) {
+    return relationType === "oneToMany" || relationType === "manyToMany";
+}
+/**
+ * Extracts two-way relationship details from collections for Zod schema generation
+ * This handles complex bidirectional relationships with parent-child tracking
+ *
+ * @param config - Appwrite configuration containing collections
+ * @returns Map of collection names to their relationship details
+ */
+export function extractTwoWayRelationships(config) {
+    const relationshipMap = new Map();
+    if (!config.collections) {
+        return relationshipMap;
+    }
+    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;
+                }
+                const relatedCollectionName = resolveCollectionName(config, relationshipAttr.relatedCollection);
+                addTwoWayRelationship(relationshipMap, collection.name, relatedCollectionName, attr.key, relationshipAttr.twoWayKey, isArrayParent, isArrayChild);
+                console.log(`Extracted relationship: ${attr.key}\n\t${collection.name} -> ${relationshipAttr.relatedCollection}, databaseId: ${collection.databaseId}`);
+            }
+        });
+    });
+    return relationshipMap;
+}
+/**
+ * Helper to add two-way relationship details to both parent and child collections
+ * @param relationshipMap - The map to add relationships to
+ * @param parentCollection - Parent collection name
+ * @param childCollection - Child collection name
+ * @param parentKey - Attribute key in parent collection
+ * @param childKey - Attribute key in child collection
+ * @param isArrayParent - Whether parent side is an array
+ * @param isArrayChild - Whether child side is an array
+ */
+function addTwoWayRelationship(relationshipMap, parentCollection, childCollection, parentKey, childKey, isArrayParent, isArrayChild) {
+    const relationshipsChild = relationshipMap.get(childCollection) || [];
+    const relationshipsParent = relationshipMap.get(parentCollection) || [];
+    relationshipsParent.push({
+        parentCollection,
+        childCollection,
+        parentKey,
+        childKey,
+        isArray: isArrayParent,
+        isChild: false,
+    });
+    relationshipsChild.push({
+        parentCollection,
+        childCollection,
+        parentKey,
+        childKey,
+        isArray: isArrayChild,
+        isChild: true,
+    });
+    relationshipMap.set(childCollection, relationshipsChild);
+    relationshipMap.set(parentCollection, relationshipsParent);
+}
+/**
+ * Extracts simple relationship information from collections for JSON schema generation
+ * This handles one-way and basic relationship tracking
+ *
+ * @param config - Appwrite configuration containing collections
+ * @returns Map of collection names to their simple relationships
+ */
+export function extractSimpleRelationships(config) {
+    const relationshipMap = new Map();
+    if (!config.collections) {
+        return relationshipMap;
+    }
+    config.collections.forEach((collection) => {
+        if (!collection.attributes) {
+            return;
+        }
+        collection.attributes.forEach((attr) => {
+            if (attr.type === "relationship" && attr.relatedCollection) {
+                const relationships = relationshipMap.get(collection.name) || [];
+                relationships.push({
+                    attributeKey: attr.key,
+                    relatedCollection: resolveCollectionName(config, attr.relatedCollection),
+                    relationType: attr.relationType || "oneToOne",
+                    isArray: isArrayRelationship(attr.relationType || "oneToOne")
+                });
+                relationshipMap.set(collection.name, relationships);
+            }
+        });
+    });
+    return relationshipMap;
+}
+/**
+ * Extracts all relationship attributes from a collection's attributes
+ * @param attributes - Array of collection attributes
+ * @returns Array of relationship attributes only
+ */
+export function filterRelationshipAttributes(attributes) {
+    return attributes.filter((attr) => attr.type === "relationship");
+}

package/dist/shared/schemaGenerator.d.ts

@@ -0,0 +1,40 @@
+import type { AppwriteConfig, Attribute } from "@njdamstra/appwrite-utils";
+export declare class SchemaGenerator {
+    private relationshipMap;
+    private config;
+    private appwriteFolderPath;
+    constructor(config: AppwriteConfig, appwriteFolderPath: string);
+    private resolveCollectionName;
+    updateYamlCollections(): void;
+    updateTsSchemas(): void;
+    /**
+     * Determines the appropriate directory for collections/tables based on API mode
+     * Uses version detection or config hints to choose between 'collections' and 'tables'
+     */
+    private getVersionAwareCollectionsDirectory;
+    /**
+     * Get directory for a specific API mode (legacy or tablesdb)
+     * @param apiMode - The API mode to get directory for
+     * @returns The directory name for the specified API mode
+     */
+    getDirectoryForApiMode(apiMode: 'legacy' | 'tablesdb'): string;
+    /**
+     * Get both directory paths for dual API support
+     * @returns Object with both collectionsDirectory and tablesDirectory paths
+     */
+    getDualDirectoryConfiguration(): {
+        collectionsDirectory: string;
+        tablesDirectory: string;
+    };
+    updateConfig(config: AppwriteConfig, isYamlConfig?: boolean): Promise<void>;
+    private updateYamlConfig;
+    private updateTypeScriptConfig;
+    private extractRelationships;
+    generateSchemas(options?: {
+        format?: "zod" | "json" | "pydantic" | "both" | "all";
+        verbose?: boolean;
+        outputDir?: string;
+    }): Promise<void>;
+    createSchemaStringV4: (name: string, attributes: Attribute[]) => string;
+    typeToZod: (attribute: Attribute) => string;
+}