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

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

@@ -1,64 +1,76 @@
-import { AttributeType } from '../attribute';
-import { LanguageMeta, Attribute, Collection } from './language';
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
 
 export class Kotlin 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 = 'Int';
-                break;
-            case AttributeType.FLOAT:
-                type = 'Float';
-                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 = "Int";
+        break;
+      case AttributeType.FLOAT:
+        type = "Float";
+        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 += '?';
+        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 && attribute.default === null) {
+      type += "?";
+    }
+    return type;
+  }
 
-    getTemplate(): string {
-        return `package io.appwrite.models
+  getTemplate(): string {
+    return `package io.appwrite.models
 
 <% for (const attribute of collection.attributes) { -%>
 <% if (attribute.type === 'relationship') { -%>
@@ -68,7 +80,7 @@ import <%- toPascalCase(collections.find(c => c.$id === attribute.relatedCollect
 <% } -%>
 /**
  * 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 attribute of collection.attributes) { -%>
@@ -87,10 +99,9 @@ data class <%- toPascalCase(collection.name) %>(
 <% } -%>
 )
 `;
-    }
+  }
 
-    getFileName(collection: Collection): string {
-        return LanguageMeta.toPascalCase(collection.name) + '.kt';
-    }
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toPascalCase(collection.name) + ".kt";
+  }
 }
-

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

@@ -1,119 +1,127 @@
-import fs = require('fs');
-import path = require('path');
+import fs from "fs";
+import path from "path";
 
 export interface Attribute {
-    key: string;
-    type: string;
-    required?: boolean;
-    array?: boolean;
-    default?: any;
-    format?: string;
-    elements?: string[];
-    relatedCollection?: string;
-    relationType?: string;
-    side?: string;
+  key: string;
+  type: string;
+  required?: boolean;
+  array?: boolean;
+  default?: any;
+  format?: string;
+  elements?: string[];
+  relatedCollection?: string;
+  relationType?: string;
+  side?: string;
 }
 
 export interface Collection {
-    $id: string;
-    name: string;
-    attributes: Attribute[];
+  $id: string;
+  name: string;
+  attributes: Attribute[];
 }
 
 export abstract class LanguageMeta {
-    constructor() {
-        if (new.target === LanguageMeta) {
-            throw new TypeError("Abstract classes can't be instantiated.");
-        }
+  constructor() {
+    if (new.target === LanguageMeta) {
+      throw new TypeError("Abstract classes can't be instantiated.");
     }
+  }
 
-    static toKebabCase(string: string): string {
-        return string
-            .replace(/[^a-zA-Z0-9\s-_]/g, '') // Remove invalid characters
-            .replace(/([a-z])([A-Z])/g, '$1-$2') // Add hyphen between camelCase
-            .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2') // Add hyphen between PascalCase
-            .replace(/[_\s]+/g, '-') // Replace spaces and underscores with hyphens
-            .replace(/^-+|-+$/g, '') // Remove leading and trailing hyphens
-            .replace(/--+/g, '-') // Replace multiple hyphens with a single hyphen
-            .toLowerCase();
-    }
+  static toKebabCase(string: string): string {
+    return string
+      .replace(/[^a-zA-Z0-9\s-_]/g, "") // Remove invalid characters
+      .replace(/([a-z])([A-Z])/g, "$1-$2") // Add hyphen between camelCase
+      .replace(/([A-Z])([A-Z][a-z])/g, "$1-$2") // Add hyphen between PascalCase
+      .replace(/[_\s]+/g, "-") // Replace spaces and underscores with hyphens
+      .replace(/^-+|-+$/g, "") // Remove leading and trailing hyphens
+      .replace(/--+/g, "-") // Replace multiple hyphens with a single hyphen
+      .toLowerCase();
+  }
 
-    static toSnakeCase(string: string): string {
-        return this.toKebabCase(string).replace(/-/g, '_');
-    }
+  static toSnakeCase(string: string): string {
+    return this.toKebabCase(string).replace(/-/g, "_");
+  }
 
-    static toUpperSnakeCase(string: string): string {
-        return this.toSnakeCase(string).toUpperCase();
-    }
+  static toUpperSnakeCase(string: string): string {
+    return this.toSnakeCase(string).toUpperCase();
+  }
 
-    static toCamelCase(string: string): string {
-        return this.toKebabCase(string).replace(/-([a-z0-9])/g, (g) => g[1].toUpperCase());
-    }
+  static toCamelCase(string: string): string {
+    return this.toKebabCase(string).replace(/-([a-z0-9])/g, (g) =>
+      g[1].toUpperCase(),
+    );
+  }
 
-    static toPascalCase(string: string): string {
-        return this.toCamelCase(string).replace(/^./, (g) => g.toUpperCase());
-    }
+  static toPascalCase(string: string): string {
+    return this.toCamelCase(string).replace(/^./, (g) => g.toUpperCase());
+  }
 
-    /**
-     * Get the type literal of the given attribute.
-     */
-    abstract getType(attribute: Attribute, collections?: Collection[], collectionName?: string): string;
+  /**
+   * Get the type literal of the given attribute.
+   */
+  abstract getType(
+    attribute: Attribute,
+    collections?: Collection[],
+    collectionName?: string,
+  ): string;
 
-    /**
-     * Returns true if the language uses a single file for all types.
-     */
-    isSingleFile(): boolean {
-        return false;
-    }
+  /**
+   * Returns true if the language uses a single file for all types.
+   */
+  isSingleFile(): boolean {
+    return false;
+  }
 
-    /**
-     * Get the EJS template used to generate the types for this language.
-     */
-    abstract getTemplate(): string;
+  /**
+   * Get the EJS template used to generate the types for this language.
+   */
+  abstract getTemplate(): string;
 
-    /**
-     * Get the file extension used by files of this language.
-     */
-    abstract getFileName(collection?: Collection): string;
+  /**
+   * Get the file extension used by files of this language.
+   */
+  abstract getFileName(collection?: Collection): string;
 }
 
 const existsFiles = (...files: string[]): boolean =>
-    files.some((file) => fs.existsSync(path.join(process.cwd(), file)));
+  files.some((file) => fs.existsSync(path.join(process.cwd(), file)));
 
 export function detectLanguage(): string {
-    if (existsFiles('tsconfig.json', 'deno.json')) {
-        return 'ts';
-    }
-    if (existsFiles('package.json')) {
-        return 'js';
-    }
-    if (existsFiles('composer.json')) {
-        return 'php';
-    }
-    if (existsFiles('requirements.txt', 'Pipfile', 'pyproject.toml')) {
-        return 'python';
-    }
-    if (existsFiles('Gemfile', 'Rakefile')) {
-        return 'ruby';
-    }
-    if (existsFiles('build.gradle.kts')) {
-        return 'kotlin';
-    }
-    if (existsFiles('build.gradle', 'pom.xml')) {
-        return 'java';
-    }
-    try {
-        if (fs.readdirSync(process.cwd()).some((file) => file.endsWith('.csproj'))) {
-            return 'dotnet';
-        }
-    } catch {
-        // Directory not readable, skip .csproj detection
-    }
-    if (existsFiles('Package.swift')) {
-        return 'swift';
-    }
-    if (existsFiles('pubspec.yaml')) {
-        return 'dart';
-    }
-    throw new Error('Could not detect language, please specify with -l');
+  if (existsFiles("tsconfig.json", "deno.json")) {
+    return "ts";
+  }
+  if (existsFiles("package.json")) {
+    return "js";
+  }
+  if (existsFiles("composer.json")) {
+    return "php";
+  }
+  if (existsFiles("requirements.txt", "Pipfile", "pyproject.toml")) {
+    return "python";
+  }
+  if (existsFiles("Gemfile", "Rakefile")) {
+    return "ruby";
+  }
+  if (existsFiles("build.gradle.kts")) {
+    return "kotlin";
+  }
+  if (existsFiles("build.gradle", "pom.xml")) {
+    return "java";
+  }
+  try {
+    if (
+      fs.readdirSync(process.cwd()).some((file) => file.endsWith(".csproj"))
+    ) {
+      return "dotnet";
+    }
+  } catch {
+    // Directory not readable, skip .csproj detection
+  }
+  if (existsFiles("Package.swift")) {
+    return "swift";
+  }
+  if (existsFiles("pubspec.yaml")) {
+    return "dart";
+  }
+  throw new Error("Could not detect language, please specify with -l");
 }

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

@@ -1,64 +1,76 @@
-import { AttributeType } from '../attribute';
-import { LanguageMeta, Attribute, Collection } from './language';
+import { AttributeType } from "../attribute.js";
+import { LanguageMeta, Attribute, Collection } from "./language.js";
 
 export class PHP extends LanguageMeta {
-    getType(attribute: Attribute, collections?: Collection[], collectionName?: string): string {
-        if (attribute.array) {
-            return 'array';
+  getType(
+    attribute: Attribute,
+    collections?: Collection[],
+    collectionName?: string,
+  ): string {
+    if (attribute.array) {
+      return "array";
+    }
+    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);
         }
-        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 = 'float';
-                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 = 'array';
-                }
-                break;
-            case AttributeType.POINT:
-            case AttributeType.LINESTRING:
-            case AttributeType.POLYGON:
-                type = 'array';
-                break;
-            default:
-                throw new Error(`Unknown attribute type: ${attribute.type}`);
+        break;
+      case AttributeType.INTEGER:
+        type = "int";
+        break;
+      case AttributeType.FLOAT:
+        type = "float";
+        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 && 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 = "array";
         }
-        return type;
+        break;
+      case AttributeType.POINT:
+      case AttributeType.LINESTRING:
+      case AttributeType.POLYGON:
+        type = "array";
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (!attribute.required && attribute.default === null) {
+      type += "|null";
     }
+    return type;
+  }
 
-    getTemplate(): string {
-        return `<?php
+  getTemplate(): string {
+    return `<?php
 namespace 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(" ")}\`.
 
 <% for (const attribute of collection.attributes) { -%>
 <% if (attribute.type === 'relationship' && !(attribute.relationType === 'manyToMany') && !(attribute.relationType === 'oneToMany' && attribute.side === 'parent')) { -%>
@@ -108,10 +120,9 @@ class <%- toPascalCase(collection.name) %> {
 <% } -%>
 }
 `;
-    }
+  }
 
-    getFileName(collection: Collection): string {
-        return LanguageMeta.toPascalCase(collection.name) + '.php';
-    }
+  getFileName(collection: Collection): string {
+    return LanguageMeta.toPascalCase(collection.name) + ".php";
+  }
 }
-