appwrite-cli 12.0.1 → 13.0.0-rc.1

package/lib/sdks.ts

@@ -0,0 +1,55 @@
+import Client = require('./client');
+import { globalConfig, localConfig } from './config';
+
+export const sdkForConsole = async (requiresAuth: boolean = true): Promise<Client> => {
+    const client = new Client();
+    const endpoint = globalConfig.getEndpoint();
+    const cookie = globalConfig.getCookie();
+    const selfSigned = globalConfig.getSelfSigned();
+
+    if (requiresAuth && cookie === '') {
+        throw new Error('Session not found. Please run `appwrite login` to create a session');
+    }
+
+    client
+        .setEndpoint(endpoint)
+        .setCookie(cookie)
+        .setProject('console')
+        .setSelfSigned(selfSigned)
+        .setLocale('en-US');
+
+    return client;
+};
+
+export const sdkForProject = async (): Promise<Client> => {
+    const client = new Client();
+    const endpoint = localConfig.getEndpoint() || globalConfig.getEndpoint();
+    const project = localConfig.getProject().projectId ? localConfig.getProject().projectId : globalConfig.getProject();
+    const key = globalConfig.getKey();
+    const cookie = globalConfig.getCookie();
+    const selfSigned = globalConfig.getSelfSigned();
+
+    if (!project) {
+        throw new Error('Project is not set. Please run `appwrite init project` to initialize the current directory with an Appwrite project.');
+    }
+
+    client
+        .setEndpoint(endpoint)
+        .setProject(project)
+        .setSelfSigned(selfSigned)
+        .setLocale('en-US');
+
+    if (cookie) {
+        return client
+            .setCookie(cookie)
+            .setMode('admin');
+    }
+
+    if (key) {
+        return client
+            .setKey(key)
+            .setMode('default');
+    }
+
+    throw new Error('Session not found. Please run `appwrite login` to create a session.');
+};

package/lib/spinner.ts

@@ -0,0 +1,118 @@
+import progress = require('cli-progress');
+import chalk = require('chalk');
+
+const SPINNER_ARC = 'arc';
+const SPINNER_DOTS = 'dots';
+
+interface SpinnerConfig {
+    interval: number;
+    frames: string[];
+}
+
+interface SpinnerPayload {
+    status: string;
+    resource: string;
+    id: string;
+    prefix?: string;
+    end?: string;
+    errorMessage?: string;
+}
+
+const spinners: Record<string, SpinnerConfig> = {
+    [SPINNER_ARC]: {
+        interval: 100,
+        frames: ['◜', '◠', '◝', '◞', '◡', '◟'],
+    },
+    [SPINNER_DOTS]: {
+        interval: 80,
+        frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
+    },
+};
+
+class Spinner {
+    static updatesBar: progress.MultiBar;
+    private bar: progress.SingleBar;
+    private spinnerInterval?: NodeJS.Timeout;
+
+    static start(clearOnComplete: boolean = true, hideCursor: boolean = true): void {
+        Spinner.updatesBar = new progress.MultiBar({
+            format: this.formatter,
+            hideCursor,
+            clearOnComplete,
+            stopOnComplete: true,
+            linewrap: true,
+            noTTYOutput: true,
+        });
+    }
+
+    static stop(): void {
+        Spinner.updatesBar.stop();
+    }
+
+    static formatter(options: any, params: any, payload: SpinnerPayload): string {
+        const status = payload.status.padEnd(12);
+        const middle = `${payload.resource} (${payload.id})`.padEnd(40);
+
+        let prefix = chalk.cyan(payload.prefix ?? '⧗');
+        let start = chalk.cyan(status);
+        let end = chalk.yellow(payload.end ?? '');
+
+        if (status.toLowerCase().trim() === 'pushed') {
+            start = chalk.greenBright.bold(status);
+            prefix = chalk.greenBright.bold('✓');
+            end = '';
+        } else if (status.toLowerCase().trim() === 'deploying') {
+            start = chalk.cyanBright.bold(status);
+        } else if (status.toLowerCase().trim() === 'deployed') {
+            start = chalk.green.bold(status);
+            prefix = chalk.green.bold('✓');
+        } else if (status.toLowerCase().trim() === 'error') {
+            start = chalk.red.bold(status);
+            prefix = chalk.red.bold('✗');
+            end = chalk.red(payload.errorMessage ?? '');
+        }
+
+        return Spinner.line(prefix, start, middle, end);
+    }
+
+    static line(prefix: string, start: string, middle: string, end: string, separator: string = '•'): string {
+        return `${prefix} ${start} ${separator} ${middle} ${!end ? '' : separator} ${end}`;
+    }
+
+    constructor(payload: SpinnerPayload, total: number = 100, startValue: number = 0) {
+        this.bar = Spinner.updatesBar.create(total, startValue, payload);
+    }
+
+    update(payload: Partial<SpinnerPayload>): this {
+        this.bar.update(payload);
+        return this;
+    }
+
+    fail(payload: Partial<SpinnerPayload>): void {
+        this.stopSpinner();
+        this.update({ status: 'Error', ...payload });
+    }
+
+    startSpinner(name: string): void {
+        let spinnerFrame = 1;
+        const spinner = spinners[name] ?? spinners['dots'];
+
+        this.spinnerInterval = setInterval(() => {
+            if (spinnerFrame === spinner.frames.length) spinnerFrame = 1;
+            this.bar.update({ prefix: spinner.frames[spinnerFrame++] });
+        }, spinner.interval);
+    }
+
+    stopSpinner(): void {
+        if (this.spinnerInterval) {
+            clearInterval(this.spinnerInterval);
+        }
+    }
+
+    replaceSpinner(name: string): void {
+        this.stopSpinner();
+        this.startSpinner(name);
+    }
+}
+
+export { Spinner, SPINNER_ARC, SPINNER_DOTS };

package/lib/type-generation/attribute.ts

@@ -0,0 +1,17 @@
+export const AttributeType = {
+    STRING: 'string',
+    INTEGER: 'integer',
+    FLOAT: 'double',
+    BOOLEAN: 'boolean',
+    DATETIME: 'datetime',
+    EMAIL: 'email',
+    IP: 'ip',
+    URL: 'url',
+    ENUM: 'enum',
+    RELATIONSHIP: 'relationship',
+    POINT: 'point',
+    LINESTRING: 'linestring',
+    POLYGON: 'polygon',
+} as const;
+
+export type AttributeTypeValue = typeof AttributeType[keyof typeof AttributeType];

package/lib/type-generation/languages/{csharp.js → csharp.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 CSharp 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 CSharp 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 = 'long';
+                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}`);
         }
-        break;
-      case AttributeType.INTEGER:
-        type = "long";
-        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 = `List<${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}>`;
+        if (!attribute.required) {
+            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;
     }
-    if (!attribute.required) {
-      type += "?";
-    }
-    return type;
-  }
 
-  getTemplate() {
-    return `/// This file is auto-generated by the Appwrite CLI. 
+    getTemplate(): string {
+        return `/// This file is auto-generated by the Appwrite CLI. 
 /// You can regenerate it by running \`appwrite ${process.argv.slice(2).join(' ')}\`.
 
 #nullable enable
@@ -169,11 +172,10 @@ public class <%= toPascalCase(collection.name) %>
 }
 }
 `;
-  }
+    }
 
-  getFileName(collection) {
-    return LanguageMeta.toPascalCase(collection.name) + ".cs";
-  }
+    getFileName(collection: Collection): string {
+        return LanguageMeta.toPascalCase(collection.name) + '.cs';
+    }
 }
 
-module.exports = { CSharp };

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

@@ -1,98 +1,101 @@
-/** @typedef {import('../attribute').Attribute} Attribute */
-const { AttributeType } = require('../attribute');
-const { LanguageMeta } = require("./language");
-const fs = require('fs');
-const path = require('path');
-
-class Dart extends LanguageMeta {
-  getPackageName() {
-    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 = [];
-            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;
+import fs = require('fs');
+import path = require('path');
+import { AttributeType } from '../attribute';
+import { LanguageMeta, Attribute, Collection } from './language';
+
+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());
                 }
 
-                dependencies.push(line.trim());
-            }
-
-            if (dependencies.some(dep => dep.startsWith('dart_appwrite:'))) {
-                return 'dart_appwrite';
-            }
-            if (dependencies.some(dep => dep.startsWith('appwrite:'))) {
-                return 'appwrite';
+                if (dependencies.some((dep) => dep.startsWith('dart_appwrite:'))) {
+                    return 'dart_appwrite';
+                }
+                if (dependencies.some((dep) => dep.startsWith('appwrite:'))) {
+                    return 'appwrite';
+                }
             }
         }
-    }
 
-    return 'appwrite';
-  }
+        return 'appwrite';
+    }
 
-  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);
+    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}`);
         }
-        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 = `List<${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}>`;
+        if (!attribute.required) {
+            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;
     }
-    if (!attribute.required) {
-      type += "?";
-    }
-    return type;
-  }
 
-  getTemplate() {
-  return `// This file is auto-generated by the Appwrite CLI. 
+    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) => {
@@ -192,11 +195,10 @@ map['<%= attribute.key %>'] != null ? <%- toPascalCase(collections.find(c => c.$
   }
 }
 `;
-  }
+    }
 
-  getFileName(collection) {
-    return LanguageMeta.toSnakeCase(collection.name) + ".dart";
-  }
+    getFileName(collection: Collection): string {
+        return LanguageMeta.toSnakeCase(collection.name) + '.dart';
+    }
 }
 
-module.exports = { Dart };

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

@@ -1,58 +1,61 @@
-/** @typedef {import('../attribute').Attribute} Attribute */
-const { AttributeType } = require('../attribute');
-const { LanguageMeta } = require("./language");
-
-class Java 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);
+import { AttributeType } from '../attribute';
+import { LanguageMeta, Attribute, Collection } from './language';
+
+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}`);
         }
-        break;
-      case AttributeType.INTEGER:
-        type = "int";
-        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.`);
+        if (attribute.array) {
+            type = 'List<' + 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;
     }
-    return type;
-  }
 
-  getTemplate() {
-    return `package io.appwrite.models;
+    getTemplate(): string {
+        return `package io.appwrite.models;
 
 /**
  * This file is auto-generated by the Appwrite CLI. 
@@ -129,11 +132,10 @@ public class <%- toPascalCase(collection.name) %> {
     }
 }
 `;
-  }
+    }
 
-  getFileName(collection) {
-    return LanguageMeta.toPascalCase(collection.name) + ".java";
-  }
+    getFileName(collection: Collection): string {
+        return LanguageMeta.toPascalCase(collection.name) + '.java';
+    }
 }
 
-module.exports = { Java };