appwrite-cli 6.2.3 → 8.0.0

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

@@ -0,0 +1,152 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class Dart extends LanguageMeta {
+  getType(attribute) {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type = 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:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = `List<${type}>`;
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = `List<${type}>`;
+    }
+    if (!attribute.required) {
+      type += "?";
+    }
+    return type;
+  }
+
+  getTemplate() {
+    return `<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import '<%- attribute.relatedCollection.toLowerCase() %>.dart';
+
+<% } -%>
+<% } -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+enum <%- toPascalCase(attribute.key) %> {
+<% for (const element of attribute.elements) { -%>
+  <%- element %>,
+<% } -%>
+}
+
+<% } -%>
+<% } -%>
+class <%= toPascalCase(collection.name) %> {
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+  <%- getType(attribute) %> <%= toCamelCase(attribute.key) %>;
+<% } -%>
+
+  <%= toPascalCase(collection.name) %>({
+  <% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+  <% if (attribute.required) { %>required <% } %>this.<%= toCamelCase(attribute.key) %>,
+  <% } -%>
+});
+
+  factory <%= toPascalCase(collection.name) %>.fromMap(Map<String, dynamic> map) {
+    return <%= toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+      <%= toCamelCase(attribute.key) %>: <% if (attribute.type === 'string' || attribute.type === 'email' || attribute.type === 'datetime') { -%>
+<% if (attribute.format === 'enum') { -%>
+<% if (attribute.array) { -%>
+(map['<%= attribute.key %>'] as List<dynamic>?)?.map((e) => <%- toPascalCase(attribute.key) %>.values.firstWhere((element) => element.name == e)).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<% if (!attribute.required) { -%>
+map['<%= attribute.key %>'] != null ? <%- toPascalCase(attribute.key) %>.values.where((e) => e.name == map['<%= attribute.key %>']).firstOrNull : null<% } else { -%>
+<%- toPascalCase(attribute.key) %>.values.firstWhere((e) => e.name == map['<%= attribute.key %>'])<% } -%>
+<% } -%>
+<% } else { -%>
+<% if (attribute.array) { -%>
+List<String>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %>?<% } %>.toString()<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } -%>
+<% } else if (attribute.type === 'integer') { -%>
+<% if (attribute.array) { -%>
+List<int>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else if (attribute.type === 'float') { -%>
+<% if (attribute.array) { -%>
+List<double>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else if (attribute.type === 'boolean') { -%>
+<% if (attribute.array) { -%>
+List<bool>.from(map['<%= attribute.key %>'] ?? [])<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+map['<%= attribute.key %>']<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else if (attribute.type === 'relationship') { -%>
+<% if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') { -%>
+(map['<%= attribute.key %>'] as List<dynamic>?)?.map((e) => <%- toPascalCase(attribute.relatedCollection) %>.fromMap(e)).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<% if (!attribute.required) { -%>
+map['<%= attribute.key %>'] != null ? <%- toPascalCase(attribute.relatedCollection) %>.fromMap(map['<%= attribute.key %>']) : null<% } else { -%>
+<%- toPascalCase(attribute.relatedCollection) %>.fromMap(map['<%= attribute.key %>'])<% } -%>
+<% } -%>
+<% } -%>,
+<% } -%>
+    );
+  }
+
+  Map<String, dynamic> toMap() {
+    return {
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+      "<%= attribute.key %>": <% if (attribute.type === 'relationship') { -%>
+<% if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') { -%>
+<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.map((e) => e.toMap()).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.toMap()<% if (!attribute.required) { %> ?? {}<% } -%>
+<% } -%>
+<% } else if (attribute.format === 'enum') { -%>
+<% if (attribute.array) { -%>
+<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.map((e) => e.name).toList()<% if (!attribute.required) { %> ?? []<% } -%>
+<% } else { -%>
+<%= toCamelCase(attribute.key) %><% if (!attribute.required) { %>?<% } %>.name<% if (!attribute.required) { %> ?? null<% } -%>
+<% } -%>
+<% } else { -%>
+<%= toCamelCase(attribute.key) -%>
+<% } -%>,
+<% } -%>
+    };
+  }
+}
+`;
+  }
+
+  getFileName(collection) {
+    return LanguageMeta.toSnakeCase(collection.name) + ".dart";
+  }
+}
+
+module.exports = { Dart };

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

@@ -0,0 +1,121 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class Java extends LanguageMeta {
+  getType(attribute) {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type = LanguageMeta.toPascalCase(attribute.key);
+        }
+        break;
+      case AttributeType.INTEGER:
+        type = "int";
+        break;
+      case AttributeType.FLOAT:
+        type = "double";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "boolean";
+        break;
+      case AttributeType.RELATIONSHIP:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = "List<" + type + ">";
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = "List<" + type + ">";
+    }
+    return type;
+  }
+
+  getTemplate() {
+    return `package io.appwrite.models;
+
+import java.util.*;
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import <%- toPascalCase(attribute.relatedCollection) %>;
+
+<% } -%>
+<% } -%>
+public class <%- toPascalCase(collection.name) %> {
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+
+    public enum <%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+        <%- element %><%- index < attribute.elements.length - 1 ? ',' : ';' %>
+<% } -%>
+    }
+
+<% } -%>
+<% } -%>
+<% for (const attribute of collection.attributes) { -%>
+    private <%- getType(attribute) %> <%- toCamelCase(attribute.key) %>;
+<% } -%>
+
+    public <%- toPascalCase(collection.name) %>() {
+    }
+
+    public <%- toPascalCase(collection.name) %>(
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+        <%- getType(attribute) %> <%= toCamelCase(attribute.key) %><%- index < collection.attributes.length - 1 ? ',' : '' %>
+<% } -%>
+    ) {
+<% for (const attribute of collection.attributes) { -%>
+        this.<%= toCamelCase(attribute.key) %> = <%= toCamelCase(attribute.key) %>;
+<% } -%>
+    }
+
+<% for (const attribute of collection.attributes) { -%>
+    public <%- getType(attribute) %> get<%- toPascalCase(attribute.key) %>() {
+        return <%= toCamelCase(attribute.key) %>;
+    }
+
+    public void set<%- toPascalCase(attribute.key) %>(<%- getType(attribute) %> <%= toCamelCase(attribute.key) %>) {
+        this.<%= toCamelCase(attribute.key) %> = <%= toCamelCase(attribute.key) %>;
+    }
+
+<% } -%>
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null || getClass() != obj.getClass()) return false;
+        <%- toPascalCase(collection.name) %> that = (<%- toPascalCase(collection.name) %>) obj;
+        return <% collection.attributes.forEach((attr, index) => { %>Objects.equals(<%= toCamelCase(attr.key) %>, that.<%= toCamelCase(attr.key) %>)<% if (index < collection.attributes.length - 1) { %> &&
+              <% } }); %>;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(<%= collection.attributes.map(attr => toCamelCase(attr.key)).join(', ') %>);
+    }
+
+    @Override
+    public String toString() {
+        return "<%- toPascalCase(collection.name) %>{" +
+<% for (const [index, attribute] of Object.entries(collection.attributes)) { -%>
+                "<%= toCamelCase(attribute.key) %>=" + <%= toCamelCase(attribute.key) %> +
+<% } -%>
+                '}';
+    }
+}
+`;
+  }
+
+  getFileName(collection) {
+    return LanguageMeta.toPascalCase(collection.name) + ".java";
+  }
+}
+
+module.exports = { Java };

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

@@ -0,0 +1,84 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const fs = require("fs");
+const path = require("path");
+
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class JavaScript extends LanguageMeta {
+  getType(attribute) {
+    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 = `"${attribute.elements.join('"|"')}"`;
+        }
+        break;
+      case AttributeType.INTEGER:
+        type = "number";
+        break;
+      case AttributeType.FLOAT:
+        type = "number";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "boolean";
+        break;
+      case AttributeType.RELATIONSHIP:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = `Array<${type}>`;
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type += "[]";
+    }
+    if (!attribute.required) {
+      type += "|null|undefined";
+    }
+    return type;
+  }
+
+  isSingleFile() {
+    return true;
+  }
+
+  _getAppwriteDependency() {
+    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['node-appwrite'] ? 'node-appwrite' : 'appwrite';
+    }
+
+    return "appwrite";
+  }
+
+  getTemplate() {
+    return `/**
+ * @typedef {import('${this._getAppwriteDependency()}').Models.Document} Document
+ */
+
+<% for (const collection of collections) { %>
+/**
+ * @typedef {Object} <%- toPascalCase(collection.name) %>
+<% for (const attribute of collection.attributes) { -%>
+ * @property {<%- getType(attribute) %>} <%- toCamelCase(attribute.key) %>
+<% } -%>
+ */
+
+<% } %>`;
+  }
+
+  getFileName(_) {
+    return "appwrite-types.js";
+  }
+}
+
+module.exports = { JavaScript }; 

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

@@ -0,0 +1,75 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class Kotlin extends LanguageMeta {
+  getType(attribute) {
+    let type = "";
+    switch (attribute.type) {
+      case AttributeType.STRING:
+      case AttributeType.EMAIL:
+      case AttributeType.DATETIME:
+        type = "String";
+        if (attribute.format === AttributeType.ENUM) {
+          type = 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:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = `List<${type}>`;
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (attribute.array) {
+      type = "List<" + type + ">";
+    }
+    if (!attribute.required) {
+      type += "?";
+    }
+    return type;
+  }
+
+  getTemplate() {
+    return `package io.appwrite.models
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship') { -%>
+import <%- toPascalCase(attribute.relatedCollection) %>
+
+<% } -%>
+<% } -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+enum class <%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+    <%- element %><%- index < attribute.elements.length - 1 ? ',' : '' %>
+<% } -%>
+}
+
+<% } -%>
+<% } -%>
+data class <%- toPascalCase(collection.name) %>(
+<% for (const attribute of collection.attributes) { -%>
+    val <%- toCamelCase(attribute.key) %>: <%- getType(attribute) %>,
+<% } -%>
+)`;
+  }
+
+  getFileName(collection) {
+    return LanguageMeta.toPascalCase(collection.name) + ".kt";
+  }
+}
+
+module.exports = { Kotlin };

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

@@ -0,0 +1,125 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+/** @typedef {import('../collection').Collection} Collection */
+
+const fs = require("fs");
+const path = require("path");
+
+class LanguageMeta {
+  constructor() {
+    if (new.target === LanguageMeta) {
+      throw new TypeError("Abstract classes can't be instantiated.");
+    }
+  }
+
+  static toKebabCase(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) {
+    return this.toKebabCase(string).replace(/-/g, "_");
+  }
+
+  static toUpperSnakeCase(string) {
+    return this.toSnakeCase(string).toUpperCase();
+  }
+
+  static toCamelCase(string) {
+    return this.toKebabCase(string).replace(/-([a-z0-9])/g, (g) =>
+      g[1].toUpperCase()
+    );
+  }
+
+  static toPascalCase(string) {
+    return this.toCamelCase(string).replace(/^./, (g) => g.toUpperCase());
+  }
+
+  /**
+   * Get the type literal of the given attribute.
+   *
+   * @abstract
+   * @param {Attribute} attribute
+   * @return {string}
+   */
+  getType(attribute) {
+    throw new TypeError("Stub.");
+  }
+
+  /**
+   * Returns true if the language uses a single file for all types.
+   *
+   * @returns {boolean}
+   */
+  isSingleFile() {
+    return false;
+  }
+
+  /**
+   * Get the EJS template used to generate the types for this language.
+   *
+   * @abstract
+   * @returns {string}
+   */
+  getTemplate() {
+    throw new TypeError("Stub.");
+  }
+
+  /**
+   * Get the file extension used by files of this language.
+   *
+   * @abstract
+   * @param {Collection|undefined} collection
+   * @returns {string}
+   */
+  getFileName(collection) {
+    throw new TypeError("Stub.");
+  }
+}
+
+const existsFiles = (...files) =>
+  files.some((file) => fs.existsSync(path.join(process.cwd(), file)));
+
+/**
+ * @returns {string}
+ */
+function detectLanguage() {
+  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";
+  }
+  if (existsFiles("*.csproj")) {
+    return "dotnet";
+  }
+  if (existsFiles("Package.swift")) {
+    return "swift";
+  }
+  if (existsFiles("pubspec.yaml")) {
+    return "dart";
+  }
+  throw new Error("Could not detect language, please specify with -l");
+}
+
+module.exports = { LanguageMeta, detectLanguage };

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

@@ -0,0 +1,100 @@
+/** @typedef {import('../attribute').Attribute} Attribute */
+const { AttributeType } = require('../attribute');
+const { LanguageMeta } = require("./language");
+
+class PHP extends LanguageMeta {
+  getType(attribute) {
+    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(attribute.key);
+        }
+        break;
+      case AttributeType.INTEGER:
+        type = "int";
+        break;
+      case AttributeType.FLOAT:
+        type = "float";
+        break;
+      case AttributeType.BOOLEAN:
+        type = "bool";
+        break;
+      case AttributeType.RELATIONSHIP:
+        type = LanguageMeta.toPascalCase(attribute.relatedCollection);
+        if ((attribute.relationType === 'oneToMany' && attribute.side === 'parent') || (attribute.relationType === 'manyToOne' && attribute.side === 'child') || attribute.relationType === 'manyToMany') {
+          type = "array";
+        }
+        break;
+      default:
+        throw new Error(`Unknown attribute type: ${attribute.type}`);
+    }
+    if (!attribute.required) {
+      type += "|null";
+    }
+    return type;
+  }
+
+  getTemplate() {
+    return `<?php
+namespace Appwrite\\Models;
+
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.type === 'relationship' && !(attribute.relationType === 'manyToMany') && !(attribute.relationType === 'oneToMany' && attribute.side === 'parent')) { -%>
+use Appwrite\\Models\\<%- toPascalCase(attribute.relatedCollection) %>;
+
+<% } -%>
+<% } -%>
+<% for (const attribute of collection.attributes) { -%>
+<% if (attribute.format === 'enum') { -%>
+enum <%- toPascalCase(attribute.key) %> {
+<% for (const [index, element] of Object.entries(attribute.elements)) { -%>
+  case <%- element.toUpperCase() %> = '<%- element %>';
+<% } -%>
+}
+
+<% } -%>
+<% } -%>
+class <%- toPascalCase(collection.name) %> {
+<% for (const attribute of collection.attributes ){ -%>
+  private <%- getType(attribute) %> $<%- toCamelCase(attribute.key) %>;
+<% } -%>
+
+  public function __construct(
+<% for (const attribute of collection.attributes ){ -%>
+<% if (attribute.required) { -%>
+    <%- getType(attribute).replace('|null', '') %> $<%- toCamelCase(attribute.key) %><% if (collection.attributes.indexOf(attribute) < collection.attributes.length - 1) { %>,<% } %>
+<% } else { -%>
+    ?<%- getType(attribute).replace('|null', '') %> $<%- toCamelCase(attribute.key) %> = null<% if (collection.attributes.indexOf(attribute) < collection.attributes.length - 1) { %>,<% } %>
+<% } -%>
+<% } -%>
+  ) {
+<% for (const attribute of collection.attributes ){ -%>
+    $this-><%- toCamelCase(attribute.key) %> = $<%- toCamelCase(attribute.key) %>;
+<% } -%>
+  }
+
+<% for (const attribute of collection.attributes ){ -%>
+  public function get<%- toPascalCase(attribute.key) %>(): <%- getType(attribute) %> {
+    return $this-><%- toCamelCase(attribute.key) %>;
+  }
+
+  public function set<%- toPascalCase(attribute.key) %>(<%- getType(attribute) %> $<%- toCamelCase(attribute.key) %>): void {
+    $this-><%- toCamelCase(attribute.key) %> = $<%- toCamelCase(attribute.key) %>;
+  }
+<% } -%>
+}`;
+  }
+
+  getFileName(collection) {
+    return LanguageMeta.toPascalCase(collection.name) + ".php";
+  }
+}
+
+module.exports = { PHP };