appwrite-cli 13.0.0-rc.1 → 13.0.0-rc.2

package/lib/type-generation/languages/dart.ts

@@ -1,102 +1,116 @@
-import fs = require('fs');
-import path = require('path');
-import { AttributeType } from '../attribute';
-import { LanguageMeta, Attribute, Collection } from './language';
+import fs from "fs";
+import path from "path";
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
 
 export class Dart extends LanguageMeta {
-    getPackageName(): string {
-        const pubspecPath = path.join(process.cwd(), 'pubspec.yaml');
-        if (fs.existsSync(pubspecPath)) {
-            const pubspecContent = fs.readFileSync(pubspecPath, 'utf8');
-            const lines = pubspecContent.split('\n');
-
-            const dependenciesIndex = lines.findIndex((line) => line.trim() === 'dependencies:');
-
-            if (dependenciesIndex !== -1) {
-                const indent = lines[dependenciesIndex].search(/\S|$/);
-                const dependencies: string[] = [];
-                for (let i = dependenciesIndex + 1; i < lines.length; i++) {
-                    const line = lines[i];
-                    if (line.trim() === '') continue;
-
-                    const lineIndent = line.search(/\S|$/);
-                    if (lineIndent <= indent && line.trim() !== '') {
-                        break;
-                    }
-
-                    dependencies.push(line.trim());
-                }
-
-                if (dependencies.some((dep) => dep.startsWith('dart_appwrite:'))) {
-                    return 'dart_appwrite';
-                }
-                if (dependencies.some((dep) => dep.startsWith('appwrite:'))) {
-                    return 'appwrite';
-                }
-            }
+  getPackageName(): string {
+    const pubspecPath = path.join(process.cwd(), "pubspec.yaml");
+    if (fs.existsSync(pubspecPath)) {
+      const pubspecContent = fs.readFileSync(pubspecPath, "utf8");
+      const lines = pubspecContent.split("\n");
+
+      const dependenciesIndex = lines.findIndex(
+        (line) => line.trim() === "dependencies:",
+      );
+
+      if (dependenciesIndex !== -1) {
+        const indent = lines[dependenciesIndex].search(/\S|$/);
+        const dependencies: string[] = [];
+        for (let i = dependenciesIndex + 1; i < lines.length; i++) {
+          const line = lines[i];
+          if (line.trim() === "") continue;
+
+          const lineIndent = line.search(/\S|$/);
+          if (lineIndent <= indent && line.trim() !== "") {
+            break;
+          }
+
+          dependencies.push(line.trim());
         }
 
-        return 'appwrite';
+        if (dependencies.some((dep) => dep.startsWith("dart_appwrite:"))) {
+          return "dart_appwrite";
+        }
+        if (dependencies.some((dep) => dep.startsWith("appwrite:"))) {
+          return "appwrite";
+        }
+      }
     }
 
-    getType(attribute: Attribute, collections?: Collection[], collectionName?: string): string {
-        let type = '';
-        switch (attribute.type) {
-            case AttributeType.STRING:
-            case AttributeType.EMAIL:
-            case AttributeType.DATETIME:
-                type = 'String';
-                if (attribute.format === AttributeType.ENUM) {
-                    type = LanguageMeta.toPascalCase(collectionName!) + LanguageMeta.toPascalCase(attribute.key);
-                }
-                break;
-            case AttributeType.INTEGER:
-                type = 'int';
-                break;
-            case AttributeType.FLOAT:
-                type = 'double';
-                break;
-            case AttributeType.BOOLEAN:
-                type = 'bool';
-                break;
-            case AttributeType.RELATIONSHIP:
-                const relatedCollection = collections?.find((c) => c.$id === attribute.relatedCollection);
-                if (!relatedCollection) {
-                    throw new Error(`Related collection with ID '${attribute.relatedCollection}' not found.`);
-                }
-                type = LanguageMeta.toPascalCase(relatedCollection.name);
-                if (
-                    (attribute.relationType === 'oneToMany' && attribute.side === 'parent') ||
-                    (attribute.relationType === 'manyToOne' && attribute.side === 'child') ||
-                    attribute.relationType === 'manyToMany'
-                ) {
-                    type = `List<${type}>`;
-                }
-                break;
-            case AttributeType.POINT:
-                type = 'List<double>';
-                break;
-            case AttributeType.LINESTRING:
-                type = 'List<List<double>>';
-                break;
-            case AttributeType.POLYGON:
-                type = 'List<List<List<double>>>';
-                break;
-            default:
-                throw new Error(`Unknown attribute type: ${attribute.type}`);
+    return "appwrite";
+  }
+
+  getType(
+    attribute: Attribute,
+    collections?: Collection[],
+    collectionName?: string,
+  ): string {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type =
+            LanguageMeta.toPascalCase(collectionName!) +
+            LanguageMeta.toPascalCase(attribute.key);
         }
-        if (attribute.array) {
-            type = `List<${type}>`;
+        break;
+      case AttributeType.INTEGER:
+        type = "int";
+        break;
+      case AttributeType.FLOAT:
+        type = "double";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "bool";
+        break;
+      case AttributeType.RELATIONSHIP:
+        const relatedCollection = collections?.find(
+          (c) => c.$id === attribute.relatedCollection,
+        );
+        if (!relatedCollection) {
+          throw new Error(
+            `Related collection with ID '${attribute.relatedCollection}' not found.`,
+          );
         }
-        if (!attribute.required) {
-            type += '?';
+        type = LanguageMeta.toPascalCase(relatedCollection.name);
+        if (
+          (attribute.relationType === "oneToMany" &&
+            attribute.side === "parent") ||
+          (attribute.relationType === "manyToOne" &&
+            attribute.side === "child") ||
+          attribute.relationType === "manyToMany"
+        ) {
+          type = `List<${type}>`;
         }
-        return type;
+        break;
+      case AttributeType.POINT:
+        type = "List<double>";
+        break;
+      case AttributeType.LINESTRING:
+        type = "List<List<double>>";
+        break;
+      case AttributeType.POLYGON:
+        type = "List<List<List<double>>>";
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
     }
+    if (attribute.array) {
+      type = `List<${type}>`;
+    }
+    if (!attribute.required) {
+      type += "?";
+    }
+    return type;
+  }
 
-    getTemplate(): string {
-        return `// This file is auto-generated by the Appwrite CLI. 
-// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(' ')}\`.
+  getTemplate(): string {
+    return `// This file is auto-generated by the Appwrite CLI. 
+// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(" ")}\`.
 <% const __relatedImportsSeen = new Set();
    const sortedAttributes = collection.attributes.slice().sort((a, b) => {
      if (a.required === b.required) return 0;
@@ -195,10 +209,9 @@ map['<%= attribute.key %>'] != null ? <%- toPascalCase(collections.find(c => c.$
   }
 }
 `;
-    }
+  }
 
-    getFileName(collection: Collection): string {
-        return LanguageMeta.toSnakeCase(collection.name) + '.dart';
-    }
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toSnakeCase(collection.name) + ".dart";
+  }
 }
-

package/lib/type-generation/languages/java.ts

@@ -1,65 +1,77 @@
-import { AttributeType } from '../attribute';
-import { LanguageMeta, Attribute, Collection } from './language';
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
 
 export class Java extends LanguageMeta {
-    getType(attribute: Attribute, collections?: Collection[], collectionName?: string): string {
-        let type = '';
-        switch (attribute.type) {
-            case AttributeType.STRING:
-            case AttributeType.EMAIL:
-            case AttributeType.DATETIME:
-                type = 'String';
-                if (attribute.format === AttributeType.ENUM) {
-                    type = LanguageMeta.toPascalCase(collectionName!) + LanguageMeta.toPascalCase(attribute.key);
-                }
-                break;
-            case AttributeType.INTEGER:
-                type = 'Integer';
-                break;
-            case AttributeType.FLOAT:
-                type = 'Double';
-                break;
-            case AttributeType.BOOLEAN:
-                type = 'Boolean';
-                break;
-            case AttributeType.RELATIONSHIP:
-                const relatedCollection = collections?.find((c) => c.$id === attribute.relatedCollection);
-                if (!relatedCollection) {
-                    throw new Error(`Related collection with ID '${attribute.relatedCollection}' not found.`);
-                }
-                type = LanguageMeta.toPascalCase(relatedCollection.name);
-                if (
-                    (attribute.relationType === 'oneToMany' && attribute.side === 'parent') ||
-                    (attribute.relationType === 'manyToOne' && attribute.side === 'child') ||
-                    attribute.relationType === 'manyToMany'
-                ) {
-                    type = 'List<' + type + '>';
-                }
-                break;
-            case AttributeType.POINT:
-                type = 'List<Double>';
-                break;
-            case AttributeType.LINESTRING:
-                type = 'List<List<Double>>';
-                break;
-            case AttributeType.POLYGON:
-                type = 'List<List<List<Double>>>';
-                break;
-            default:
-                throw new Error(`Unknown attribute type: ${attribute.type}`);
+  getType(
+    attribute: Attribute,
+    collections?: Collection[],
+    collectionName?: string,
+  ): string {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type =
+            LanguageMeta.toPascalCase(collectionName!) +
+            LanguageMeta.toPascalCase(attribute.key);
         }
-        if (attribute.array) {
-            type = 'List<' + type + '>';
+        break;
+      case AttributeType.INTEGER:
+        type = "Integer";
+        break;
+      case AttributeType.FLOAT:
+        type = "Double";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "Boolean";
+        break;
+      case AttributeType.RELATIONSHIP:
+        const relatedCollection = collections?.find(
+          (c) => c.$id === attribute.relatedCollection,
+        );
+        if (!relatedCollection) {
+          throw new Error(
+            `Related collection with ID '${attribute.relatedCollection}' not found.`,
+          );
         }
-        return type;
+        type = LanguageMeta.toPascalCase(relatedCollection.name);
+        if (
+          (attribute.relationType === "oneToMany" &&
+            attribute.side === "parent") ||
+          (attribute.relationType === "manyToOne" &&
+            attribute.side === "child") ||
+          attribute.relationType === "manyToMany"
+        ) {
+          type = "List<" + type + ">";
+        }
+        break;
+      case AttributeType.POINT:
+        type = "List<Double>";
+        break;
+      case AttributeType.LINESTRING:
+        type = "List<List<Double>>";
+        break;
+      case AttributeType.POLYGON:
+        type = "List<List<List<Double>>>";
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = "List<" + type + ">";
     }
+    return type;
+  }
 
-    getTemplate(): string {
-        return `package io.appwrite.models;
+  getTemplate(): string {
+    return `package io.appwrite.models;
 
 /**
  * This file is auto-generated by the Appwrite CLI. 
- * You can regenerate it by running \`appwrite ${process.argv.slice(2).join(' ')}\`.
+ * You can regenerate it by running \`appwrite ${process.argv.slice(2).join(" ")}\`.
  */
 
 import java.util.Objects;
@@ -132,10 +144,9 @@ public class <%- toPascalCase(collection.name) %> {
     }
 }
 `;
-    }
+  }
 
-    getFileName(collection: Collection): string {
-        return LanguageMeta.toPascalCase(collection.name) + '.java';
-    }
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toPascalCase(collection.name) + ".java";
+  }
 }
-

package/lib/type-generation/languages/javascript.ts

@@ -1,87 +1,98 @@
-import fs = require('fs');
-import path = require('path');
-import { AttributeType } from '../attribute';
-import { LanguageMeta, Attribute, Collection } from './language';
+import fs from "fs";
+import path from "path";
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
 
 export class JavaScript extends LanguageMeta {
-    getType(attribute: Attribute, collections?: Collection[]): string {
-        let type = '';
-        switch (attribute.type) {
-            case AttributeType.STRING:
-            case AttributeType.EMAIL:
-            case AttributeType.DATETIME:
-            case AttributeType.IP:
-            case AttributeType.URL:
-                type = 'string';
-                if (attribute.format === AttributeType.ENUM) {
-                    type = LanguageMeta.toPascalCase(attribute.key);
-                }
-                break;
-            case AttributeType.INTEGER:
-                type = 'number';
-                break;
-            case AttributeType.FLOAT:
-                type = 'number';
-                break;
-            case AttributeType.BOOLEAN:
-                type = 'boolean';
-                break;
-            case AttributeType.RELATIONSHIP:
-                const relatedCollection = collections?.find((c) => c.$id === attribute.relatedCollection);
-                if (!relatedCollection) {
-                    throw new Error(`Related collection with ID '${attribute.relatedCollection}' not found.`);
-                }
-                type = LanguageMeta.toPascalCase(relatedCollection.name);
-                if (
-                    (attribute.relationType === 'oneToMany' && attribute.side === 'parent') ||
-                    (attribute.relationType === 'manyToOne' && attribute.side === 'child') ||
-                    attribute.relationType === 'manyToMany'
-                ) {
-                    type = `${type}[]`;
-                }
-                break;
-            case AttributeType.POINT:
-                type = 'number[]';
-                break;
-            case AttributeType.LINESTRING:
-                type = 'number[][]';
-                break;
-            case AttributeType.POLYGON:
-                type = 'number[][][]';
-                break;
-            default:
-                throw new Error(`Unknown attribute type: ${attribute.type}`);
+  getType(attribute: Attribute, collections?: Collection[]): string {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+      case AttributeType.IP:
+      case AttributeType.URL:
+        type = "string";
+        if (attribute.format === AttributeType.ENUM) {
+          type = LanguageMeta.toPascalCase(attribute.key);
         }
-        if (attribute.array) {
-            type += '[]';
+        break;
+      case AttributeType.INTEGER:
+        type = "number";
+        break;
+      case AttributeType.FLOAT:
+        type = "number";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "boolean";
+        break;
+      case AttributeType.RELATIONSHIP:
+        const relatedCollection = collections?.find(
+          (c) => c.$id === attribute.relatedCollection,
+        );
+        if (!relatedCollection) {
+          throw new Error(
+            `Related collection with ID '${attribute.relatedCollection}' not found.`,
+          );
         }
-        if (!attribute.required && attribute.default === null) {
-            type += ' | null';
+        type = LanguageMeta.toPascalCase(relatedCollection.name);
+        if (
+          (attribute.relationType === "oneToMany" &&
+            attribute.side === "parent") ||
+          (attribute.relationType === "manyToOne" &&
+            attribute.side === "child") ||
+          attribute.relationType === "manyToMany"
+        ) {
+          type = `${type}[]`;
         }
-        return type;
+        break;
+      case AttributeType.POINT:
+        type = "number[]";
+        break;
+      case AttributeType.LINESTRING:
+        type = "number[][]";
+        break;
+      case AttributeType.POLYGON:
+        type = "number[][][]";
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
     }
-
-    isSingleFile(): boolean {
-        return true;
+    if (attribute.array) {
+      type += "[]";
+    }
+    if (!attribute.required && attribute.default === null) {
+      type += " | null";
     }
+    return type;
+  }
 
-    private _getAppwriteDependency(): string {
-        if (fs.existsSync(path.resolve(process.cwd(), 'package.json'))) {
-            const packageJsonRaw = fs.readFileSync(path.resolve(process.cwd(), 'package.json'));
-            const packageJson = JSON.parse(packageJsonRaw.toString('utf-8'));
-            return packageJson.dependencies && packageJson.dependencies['node-appwrite'] ? 'node-appwrite' : 'appwrite';
-        }
+  isSingleFile(): boolean {
+    return true;
+  }
 
-        return 'appwrite';
+  private _getAppwriteDependency(): string {
+    if (fs.existsSync(path.resolve(process.cwd(), "package.json"))) {
+      const packageJsonRaw = fs.readFileSync(
+        path.resolve(process.cwd(), "package.json"),
+      );
+      const packageJson = JSON.parse(packageJsonRaw.toString("utf-8"));
+      return packageJson.dependencies &&
+        packageJson.dependencies["node-appwrite"]
+        ? "node-appwrite"
+        : "appwrite";
     }
 
-    getTemplate(): string {
-        return `/**
+    return "appwrite";
+  }
+
+  getTemplate(): string {
+    return `/**
  * @typedef {import('${this._getAppwriteDependency()}').Models.Row} Row
  */
 
 // This file is auto-generated by the Appwrite CLI.
-// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(' ')}\`.
+// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(" ")}\`.
 
 <% for (const collection of collections) { -%>
 <% for (const attribute of collection.attributes) { -%>
@@ -103,9 +114,9 @@ export class JavaScript extends LanguageMeta {
 <% if (index < collections.length - 1) { %>
 <% } -%>
 <% } %>`;
-    }
+  }
 
-    getFileName(_: Collection | undefined): string {
-        return 'appwrite-types.js';
-    }
+  getFileName(_: Collection | undefined): string {
+    return "appwrite-types.js";
+  }
 }