appwrite-cli 12.0.1 → 13.0.0-rc.1

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

@@ -0,0 +1,111 @@
+import fs = require('fs');
+import path = require('path');
+import { AttributeType } from '../attribute';
+import { LanguageMeta, Attribute, Collection } from './language';
+
+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}`);
+        }
+        if (attribute.array) {
+            type += '[]';
+        }
+        if (!attribute.required && attribute.default === null) {
+            type += ' | null';
+        }
+        return type;
+    }
+
+    isSingleFile(): boolean {
+        return true;
+    }
+
+    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';
+        }
+
+        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(' ')}\`.
+
+<% for (const collection of collections) { -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+/**
+ * @typedef {"<%- attribute.elements.join('"|"') %>"} <%- toPascalCase(attribute.key) %>
+ */
+
+<% } -%>
+<% } -%>
+<% } -%>
+<% for (const [index, collection] of Object.entries(collections)) { %>/**
+ * @typedef {Row & {
+<% for (const attribute of collection.attributes) { -%>
+ *   <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute, collections) %>;
+<% } -%>
+ * }} <%- toPascalCase(collection.name) %>
+ */
+<% if (index < collections.length - 1) { %>
+<% } -%>
+<% } %>`;
+    }
+
+    getFileName(_: Collection | undefined): string {
+        return 'appwrite-types.js';
+    }
+}

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

@@ -0,0 +1,96 @@
+import { AttributeType } from '../attribute';
+import { LanguageMeta, Attribute, Collection } from './language';
+
+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}`);
+        }
+        if (attribute.array) {
+            type = 'List<' + type + '>';
+        }
+        if (!attribute.required && attribute.default === null) {
+            type += '?';
+        }
+        return type;
+    }
+
+    getTemplate(): string {
+        return `package io.appwrite.models
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import <%- toPascalCase(collections.find(c => c.$id === attribute.relatedCollection).name) %>
+
+<% } -%>
+<% } -%>
+/**
+ * This file is auto-generated by the Appwrite CLI. 
+ * You can regenerate it by running \`appwrite ${process.argv.slice(2).join(' ')}\`.
+ */
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+enum class <%- toPascalCase(collection.name) %><%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+    <%- strict ? toUpperSnakeCase(element) : element %><%- index < attribute.elements.length - 1 ? ',' : '' %>
+<% } -%>
+}
+
+<% } -%>
+<% } -%>
+data class <%- toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+    val <%- strict ? toCamelCase(attribute.key) : attribute.key %>: <%- getType(attribute, collections, collection.name) %><% if (index < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+)
+`;
+    }
+
+    getFileName(collection: Collection): string {
+        return LanguageMeta.toPascalCase(collection.name) + '.kt';
+    }
+}
+

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

@@ -0,0 +1,119 @@
+import fs = require('fs');
+import path = require('path');
+
+export interface Attribute {
+    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[];
+}
+
+export abstract class LanguageMeta {
+    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 toSnakeCase(string: string): string {
+        return this.toKebabCase(string).replace(/-/g, '_');
+    }
+
+    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 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;
+
+    /**
+     * 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 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)));
+
+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');
+}

package/lib/type-generation/languages/{php.js → php.ts}

@@ -1,57 +1,60 @@
-/** @typedef {import('../attribute').Attribute} Attribute */
-const { AttributeType } = require('../attribute');
-const { LanguageMeta } = require("./language");
+import { AttributeType } from '../attribute';
+import { LanguageMeta, Attribute, Collection } from './language';
 
-class PHP extends LanguageMeta {
-  getType(attribute, collections, collectionName) {
-    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);
+export class PHP extends LanguageMeta {
+    getType(attribute: Attribute, collections?: Collection[], collectionName?: string): string {
+        if (attribute.array) {
+            return 'array';
         }
-        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.`);
+        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}`);
         }
-        type = LanguageMeta.toPascalCase(relatedCollection.name);
-        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
-          type = "array";
+        if (!attribute.required && attribute.default === null) {
+            type += '|null';
         }
-        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;
     }
-    return type;
-  }
 
-  getTemplate() {
-    return `<?php
+    getTemplate(): string {
+        return `<?php
 namespace Appwrite\\Models;
 
 // This file is auto-generated by the Appwrite CLI. 
@@ -105,11 +108,10 @@ class <%- toPascalCase(collection.name) %> {
 <% } -%>
 }
 `;
-  }
+    }
 
-  getFileName(collection) {
-    return LanguageMeta.toPascalCase(collection.name) + ".php";
-  }
+    getFileName(collection: Collection): string {
+        return LanguageMeta.toPascalCase(collection.name) + '.php';
+    }
 }
 
-module.exports = { PHP };

package/lib/type-generation/languages/{swift.js → swift.ts}

@@ -1,61 +1,64 @@
-/** @typedef {import('../attribute').Attribute} Attribute */
-const { AttributeType } = require('../attribute');
-const { LanguageMeta } = require("./language");
+import { AttributeType } from '../attribute';
+import { LanguageMeta, Attribute, Collection } from './language';
 
-class Swift extends LanguageMeta {
-  getType(attribute, collections, collectionName) {
-    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);
+export class Swift 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 = '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 = `[${type}]`;
+                }
+                break;
+            case AttributeType.POINT:
+                type = '[Double]';
+                break;
+            case AttributeType.LINESTRING:
+                type = '[[Double]]';
+                break;
+            case AttributeType.POLYGON:
+                type = '[[[Double]]]';
+                break;
+            default:
+                throw new Error(`Unknown attribute type: ${attribute.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.array) {
+            type = '[' + type + ']';
         }
-        type = LanguageMeta.toPascalCase(relatedCollection.name);
-        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
-          type = `[${type}]`;
+        if (!attribute.required && attribute.default === null) {
+            type += '?';
         }
-        break;
-      case AttributeType.POINT:
-        type = "[Double]";
-        break;
-      case AttributeType.LINESTRING:
-        type = "[[Double]]";
-        break;
-      case AttributeType.POLYGON:
-        type = "[[[Double]]]";
-        break;
-      default:
-        throw new Error(`Unknown attribute type: ${attribute.type}`);
+        return type;
     }
-    if (attribute.array) {
-      type = "[" + type + "]";
-    }
-    if (!attribute.required && attribute.default === null) {
-      type += "?";
-    }
-    return type;
-  }
 
-  getTemplate() {
-    return `import Foundation
+    getTemplate(): string {
+        return `import Foundation
 
 /// This file is auto-generated by the Appwrite CLI. 
 /// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(' ')}\`.
@@ -168,11 +171,10 @@ public class <%- toPascalCase(collection.name) %>: Codable {
         )
     }
 }`;
-  }
+    }
 
-  getFileName(collection) {
-    return LanguageMeta.toPascalCase(collection.name) + ".swift";
-  }
+    getFileName(collection: Collection): string {
+        return LanguageMeta.toPascalCase(collection.name) + '.swift';
+    }
 }
 
-module.exports = { Swift };