@cododel/alto 0.1.5 → 0.1.7

package/dist/default/default/extensions/filters/comment.ts

@@ -0,0 +1,9 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function comment(context: TemplateContext, str: Array<any> | string) {
+  if (Array.isArray(str)) {
+    str = str.join("\n").replace(/(^\n*)|(\n*$)/gi, "");
+  }
+  str = str.split("\n");
+  return `/**\n${str.map((line) => ` * ${line}`).join("\n")}\n*/`;
+}

package/dist/default/default/extensions/filters/contains.ts

@@ -0,0 +1,8 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function contains(context: TemplateContext, arr: any, value: any) {
+  if (!Array.isArray(arr)) {
+    return false;
+  }
+  return typeof arr.find((v) => v == value) != "undefined";
+}

package/dist/default/default/extensions/filters/directus.ts

@@ -0,0 +1,336 @@
+import { Collection, Field } from "../../../types/registry";
+
+import { json } from "./json";
+import { quote, quoted } from "./quote";
+
+import { match } from "ts-pattern";
+import type { TemplateContext } from "../../../types/template";
+import { drop_first } from "./drop_first";
+import { regex_replace } from "./regex_replace";
+import { split } from "./split";
+import { lower_case, pascal_case, space_case } from "./string_cases";
+import { isManyToOne, isOneToMany } from "../../../types/relationships";
+
+export function to_collection_text(
+  context: TemplateContext,
+  value: string,
+  prefix: string = "",
+  suffix: string = "",
+) {
+  return `${prefix}${lower_case(context, space_case(context, value))}${suffix}`;
+}
+
+export function to_collection_string(context: TemplateContext, value: String) {
+  return quoted(context, value);
+}
+
+export function to_collection_name(
+  context: TemplateContext,
+  value: string,
+  partial = false,
+) {
+  value = `${value}`;
+  const system = context.registry.collections.find(
+    (c) => c.name.raw == value,
+  )?.is_system;
+  let name = pascal_case(context, value);
+  if (system) {
+    if (partial) {
+      name = regex_replace(
+        context,
+        pascal_case(context, drop_first(context, split(context, value, "_"))),
+        "s$",
+        "",
+      );
+      name = name == "Setting" ? "Settings" : name;
+      name = name == "Acces" ? "Access" : name;
+    } else {
+      name = regex_replace(context, pascal_case(context, value), "s$", "");
+      name = name == "DirectusSetting" ? "DirectusSettings" : name;
+      name = name == "DirectusAcces" ? "DirectusAccess" : name;
+      name = name == "DirectusComment" ? "DirectusActivity" : name;
+    }
+  }
+  return name;
+}
+
+export function to_ts_type(context: TemplateContext, field: Field) {
+  if (!field.type.is_data) {
+    return "never";
+  }
+
+  let types: string[] = [];
+  let schema = field.type;
+  let meta = field.type.raw?.meta;
+  let nullable = false;
+
+  let db_type = match(
+    field?.type?.database?.split("(", 2)[0]!.toLowerCase().trim(),
+  )
+    .returnType<string | false>()
+    .with("uuid", () => "Types.UUID")
+    .with("json", () => "Types.JSON")
+    .with("text", () => "Types.String")
+    .with("integer", () => "Types.Integer")
+    .with("decimal", () => "Types.Decimal")
+    .with("numeric", () => "Types.Number")
+    .with("bigint", () => "Types.BigInteger")
+    .with("boolean", () => "Types.Boolean")
+    .with("character varying", () => "Types.String")
+    .with("date", () => "Types.Date")
+    .with("time", () => "Types.DateTime")
+    .with("time with time zone", () => "Types.DateTime")
+    .with("time without time zone", () => "Types.DateTime")
+    .with("timestamp", () => "Types.DateTime")
+    .with("timestamp with time zone", () => "Types.DateTime")
+    .with("timestamp without time zone", () => "Types.DateTime")
+
+    // Shared
+    .with("boolean", () => "Types.Boolean")
+    .with("tinyint", () => "Types.Integer")
+    .with("smallint", () => "Types.Integer")
+    .with("mediumint", () => "Types.Integer")
+    .with("int", () => "Types.Integer")
+    .with("integer", () => "Types.Integer")
+    .with("serial", () => "Types.Integer")
+    .with("bigint", () => "Types.BigInteger")
+    .with("bigserial", () => "Types.BigInteger")
+    .with("clob", () => "Types.Text")
+    .with("tinytext", () => "Types.Text")
+    .with("mediumtext", () => "Types.Text")
+    .with("longtext", () => "Types.Text")
+    .with("text", () => "Types.Text")
+    .with("varchar", () => "Types.String")
+    .with("longvarchar", () => "Types.String")
+    .with("varchar2", () => "Types.String")
+    .with("nvarchar", () => "Types.String")
+    .with("image", () => "Types.Binary")
+    .with("ntext", () => "Types.Text")
+    .with("char", () => "Types.String")
+    .with("date", () => "Types.Date")
+    .with("datetime", () => "Types.DateTime")
+    .with("dateTime", () => "Types.DateTime")
+    .with("timestamp", () => "Types.DateTime")
+    .with("time", () => "Types.DateTime")
+    .with("float", () => "Types.Float")
+    .with("double", () => "Types.Float")
+    .with("double precision", () => "Types.Float")
+    .with("real", () => "Types.Float")
+    .with("decimal", () => "Types.Decimal")
+    .with("numeric", () => "Types.Integer")
+
+    // Geometries
+    .with("geometry", () => "Types.Geometry.Geometry")
+    .with("point", () => "Types.Geometry.Point")
+    .with("linestring", () => "Types.Geometry.LineString")
+    .with("polygon", () => "Types.Geometry.Polygon")
+    .with("multipoint", () => "Types.Geometry.MultiPoint")
+    .with("multilinestring", () => "Types.Geometry.MultiLineString")
+    .with("multipolygon", () => "Types.Geometry.MultiPolygon")
+
+    // MySQL
+    .with("string", () => "Types.Text")
+    .with("year", () => "Types.Integer")
+    .with("blob", () => "Types.Binary")
+    .with("mediumblob", () => "Types.Binary")
+    .with("int unsigned", () => "Types.Integer")
+    .with("tinyint unsigned", () => "Types.Integer")
+    .with("smallint unsigned", () => "Types.Integer")
+    .with("mediumint unsigned", () => "Types.Integer")
+    .with("bigint unsigned", () => "Types.Integer")
+
+    // MS SQL
+    .with("bit", () => "Types.Boolean")
+    .with("smallmoney", () => "Types.Float")
+    .with("money", () => "Types.Float")
+    .with("datetimeoffset", () => "Types.DateTime")
+    .with("datetime2", () => "Types.DateTime")
+    .with("smalldatetime", () => "Types.DateTime")
+    .with("nchar", () => "Types.Text")
+    .with("binary", () => "Types.Binary")
+    .with("varbinary", () => "Types.Binary")
+    .with("uniqueidentifier", () => "Types.UUID")
+
+    // Postgres
+    .with("json", () => "Types.JSON")
+    .with("jsonb", () => "Types.JSON")
+    .with("uuid", () => "Types.UUID")
+    .with("int2", () => "Types.Integer")
+    .with("serial4", () => "Types.Integer")
+    .with("int4", () => "Types.Integer")
+    .with("serial8", () => "Types.Integer")
+    .with("int8", () => "Types.Integer")
+    .with("bool", () => "Types.Boolean")
+    .with("character varying", () => "Types.String")
+    .with("character", () => "Types.String")
+    .with("interval", () => "Types.String")
+    .with("_varchar", () => "Types.String")
+    .with("bpchar", () => "Types.String")
+    .with("timestamptz", () => "Types.DateTime")
+    .with("timestamp with time zone", () => "Types.DateTime")
+    .with("timestamp with local time zone", () => "Types.DateTime")
+    .with("timestamp without time zone", () => "Types.Date")
+    .with("timestamp without local time zone", () => "Types.Date")
+    .with("timetz", () => "Types.DateTime")
+    .with("time with time zone", () => "Types.DateTime")
+    .with("time without time zone", () => "Types.DateTime")
+    .with("float4", () => "Types.Float")
+    .with("float8", () => "Types.Float")
+    .with("citext", () => "Types.Text")
+    .with("enum", () => "Types.Enum")
+
+    // Oracle
+    .with("number", () => "Types.Integer")
+    .with("sdo_geometry", () => "Types.Geometry.Geometry")
+
+    // SQLite
+    .with("integerfirst", () => "Types.Integer")
+
+    .otherwise(() => false);
+
+  if (db_type) {
+    types.push(db_type);
+  }
+
+  let json_type: string | false = false;
+  if (field.type.is_json) {
+    if ("json_schema" in schema) {
+      json_type = "Types.JSONSchema";
+    } else {
+      json_type = "Types.JSON";
+    }
+  }
+
+  switch (meta?.interface) {
+    case "tags":
+      types.unshift("Types.String[]");
+      break;
+    case "select-dropdown":
+      let values = (meta?.options?.choices ?? []).map((v: any) =>
+        quote(context, v.value),
+      );
+      for (let value of values) {
+        if (value == null) {
+          nullable = true;
+        } else {
+          types.unshift(value);
+        }
+      }
+      json_type = false;
+      break;
+  }
+
+  if (schema.raw?.schema?.is_nullable) {
+    // types.push('null')
+    nullable = true;
+  }
+
+  if (json_type != false) {
+    types.unshift(json_type);
+  }
+
+  if (field.type.is_relationship) {
+    //if (
+    //  field.type.is_special("user-created") ||
+    //  field.type.is_special("user-updated")
+    //) {
+    //  types.push("Collections.DirectusUser");
+    //} else if (field.type.is_special("file")) {
+    //  types.push("Collections.DirectusFile");
+    //} else if (field.type.is_special("files")) {
+    //  types.push("Collections.DirectusFile[]");
+    //} else
+    if (field.is_translations) {
+      types.push(
+        `${to_collection_name(context, field.translations_collection)}[]`,
+      );
+    } else {
+      let suffix =
+        (((isManyToOne(field.type.relationship) ||
+          isOneToMany(field.type.relationship)) &&
+          field.type.relationship.many) ??
+        field.type.is_special("m2m"))
+          ? "[]"
+          : "";
+
+      if (field.type.relationship?.type == "o2m") {
+        types.push(
+          `Collections.${to_collection_name(
+            context,
+            field.type.relationship.ref.collection,
+          )}${suffix}`,
+        );
+      }
+      if (field.type.relationship?.type == "m2o") {
+        types.push(
+          `Collections.${to_collection_name(
+            context,
+            field.type.relationship.ref.collection,
+          )}${suffix}`,
+        );
+      }
+      if (field.type.relationship?.type == "a2o") {
+        field.type.relationship.refs.forEach((ref) => {
+          types.push(
+            `Collections.${to_collection_name(
+              context,
+              ref.collection,
+            )}${suffix}`,
+          );
+        });
+      }
+      if (field.type.relationship?.type == "unmapped") {
+        types.push("any");
+      }
+    }
+  }
+
+  if (types.length <= 0) {
+    let schemaStr = json(context, schema);
+    let metaStr = json(context, meta);
+    let unknown = `Types.UnknownType<{ schema: ${schemaStr}, meta: ${metaStr} }>`;
+    types.unshift(unknown);
+  }
+
+  let output = types.join(" | ");
+  if (nullable) {
+    output = `Types.Optional<${output}>`;
+  }
+
+  if (field.type.raw?.schema?.is_primary_key ?? false) {
+    output = `Types.PrimaryKey<${output}>`;
+  }
+
+  return output;
+}
+
+export function only_system_fields(_context: TemplateContext, fields: Field[]) {
+  return fields.filter((field) => field.is_system);
+}
+
+export function only_custom_fields(_context: TemplateContext, fields: Field[]) {
+  return fields.filter((field) => !field.is_system);
+}
+
+export function only_with_custom_fields(
+  _context: TemplateContext,
+  collections: Collection[],
+) {
+  return collections.filter(
+    (field) => field.fields.filter((field) => !field.is_system).length > 0,
+  );
+}
+
+export function skip_collections(
+  context: TemplateContext,
+  collections: Collection[],
+  skipList?: string[],
+) {
+  // Используем skipList из параметров или из контекста или дефолтное значение
+  const skipCollections = skipList ??
+    context.skipCollections ?? ["directus_comments"];
+
+  return collections.filter(
+    (collection) => !skipCollections.includes(collection.name.raw),
+  );
+}

package/dist/default/default/extensions/filters/drop_first.ts

@@ -0,0 +1,8 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function drop_first(context: TemplateContext, arr: Array<any>) {
+  if (Array.isArray(arr)) {
+    arr.shift();
+  }
+  return arr;
+}

package/dist/default/default/extensions/filters/entries.ts

@@ -0,0 +1,13 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function entries(
+  context: TemplateContext,
+  obj: any,
+  keyName?: string,
+  valueName?: string,
+) {
+  return Object.entries(obj).map(([key, value]) => ({
+    [keyName ?? "key"]: key,
+    [valueName ?? "value"]: value,
+  }));
+}

package/dist/default/default/extensions/filters/falsey.ts

@@ -0,0 +1,17 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function falsey(
+  context: TemplateContext,
+  condition: boolean,
+  falsey: any,
+  truthy: any,
+) {
+  if (!condition) {
+    return falsey;
+  } else {
+    if (typeof truthy != "undefined") {
+      return truthy;
+    }
+  }
+  return condition;
+}

package/dist/default/default/extensions/filters/indent.ts

@@ -0,0 +1,6 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function indent(context: TemplateContext, value: string, size: number) {
+  const indent = new Array(size + 1).join(" ");
+  return `${indent}${value.split("\n").join(`\n${indent}`)}`;
+}

package/dist/default/default/extensions/filters/inflections.ts

@@ -0,0 +1,25 @@
+import type { TemplateContext } from "../../../types/template";
+
+import $ from "pluralize";
+
+export function to_singular(context: TemplateContext, value: any) {
+  if (typeof value !== "string") {
+    console.warn(`WARNING: trying to singularize a non-string value: ${JSON.stringify(value)}`);
+    return value;
+  }
+  return `${$.singular(`${value}`)}`;
+}
+
+export const singularize = to_singular;
+export const singular = to_singular;
+
+export function to_plural(context: TemplateContext, value: any) {
+  if (typeof value !== "string") {
+    console.warn(`WARNING: trying to pluralize a non-string value: ${JSON.stringify(value)}`);
+    return value;
+  }
+  return `${$.plural(value)}`;
+}
+
+export const pluralize = to_plural;
+export const plural = to_plural;

package/dist/default/default/extensions/filters/json.ts

@@ -0,0 +1,10 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function json(context: TemplateContext, v: any) {
+  if (typeof v == "undefined") {
+    return "undefined";
+  } else if (v === null) {
+    return "null";
+  }
+  return JSON.stringify(v, null, 2);
+}

package/dist/default/default/extensions/filters/log.ts

@@ -0,0 +1,5 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function log(context: TemplateContext, ...values: any[]) {
+  console.log(JSON.stringify({ values }));
+}

package/dist/default/default/extensions/filters/object_set.ts

@@ -0,0 +1,11 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function object_set(
+  context: TemplateContext,
+  obj: any,
+  key: string,
+  value: any,
+) {
+  obj[key] = value;
+  return obj;
+}

package/dist/default/default/extensions/filters/push.ts

@@ -0,0 +1,10 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function push(context: TemplateContext, arr: Array<any>, value: any) {
+  if (Array.isArray(value)) {
+    arr.push(...value);
+  } else {
+    arr.push(value);
+  }
+  return arr;
+}

package/dist/default/default/extensions/filters/quote.ts

@@ -0,0 +1,19 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function quote(context: TemplateContext, value: any) {
+  value = `${value}`;
+  if (typeof value == "string") {
+    return JSON.stringify(value);
+  } else if (Array.isArray(value)) {
+    return value.map((e) => {
+      if (typeof e == "string") {
+        return JSON.stringify(e);
+      } else {
+        return e;
+      }
+    });
+  }
+  return value;
+}
+
+export const quoted = quote;

package/dist/default/default/extensions/filters/regex_replace.ts

@@ -0,0 +1,10 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function regex_replace(
+  context: TemplateContext,
+  value: string,
+  regex: string,
+  replacement: string,
+) {
+  return value.replace(new RegExp(regex, "g"), replacement);
+}

package/dist/default/default/extensions/filters/splice.ts

@@ -0,0 +1,13 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function splice(
+  context: TemplateContext,
+  arr: Array<any>,
+  start: number,
+  count: number | undefined = undefined,
+) {
+  if (Array.isArray(arr)) {
+    return arr.splice(start, count);
+  }
+  return arr;
+}

package/dist/default/default/extensions/filters/split.ts

@@ -0,0 +1,9 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function split(
+  context: TemplateContext,
+  value: string,
+  splitter: string,
+) {
+  return `${value}`.split(splitter);
+}

package/dist/default/default/extensions/filters/string_cases.ts

@@ -0,0 +1,72 @@
+import type { TemplateContext } from "../../../types/template";
+
+function stringifyFirst(fn: (...args: any[]) => any) {
+  return (_context: TemplateContext, first: any, ...args: any[]) => {
+    return fn(`${first}`, ...args).toString();
+  };
+}
+
+export const lower_case = stringifyFirst(toLower);
+export const pascal_case = stringifyFirst(toPascal);
+export const space_case = stringifyFirst(toSpace);
+export const camel_case = stringifyFirst(toCamel);
+
+/**
+ * Converts a string to lower case.
+ * Example: "HelloWorld" -> "hello world"
+ * @param {string} str - The input string.
+ * @returns {string} The lowercased string.
+ * @throws {Error} If the argument is not a string.
+ */
+export function toLower(str: string) {
+  if (typeof str !== "string") {
+    throw new Error("Argument must be a string");
+  }
+  return str.toLowerCase();
+}
+
+/**
+ * Converts a string to space case.
+ * Example: "HelloWorld" -> "hello world"
+ * @param {string} str - The input string.
+ * @returns {string} The spacecased string.
+ * @throws {Error} If the argument is not a string.
+ */
+export function toSpace(str: string) {
+  if (typeof str !== "string") {
+    throw new Error("Argument must be a string");
+  }
+
+  return str
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .replace(/[\-_]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * Converts a string to PascalCase.
+ * Example: "hello world" -> "HelloWorld"
+ * @param {string} str - The input string.
+ * @returns {string} The Pascalcased string.
+ * @throws {Error} If the argument is not a string.
+ */
+export function toPascal(str: string): string {
+  return str
+    .split(/[-_\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join("");
+}
+
+/**
+ * Converts a string to camelCase.
+ * Example: "HelloWorld" -> "helloWorld"
+ * @param {string} str - The input string.
+ * @returns {string} The camelcased string.
+ * @throws {Error} If the argument is not a string.
+ */
+export function toCamel(str: string): string {
+  const pascal = toPascal(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}

package/dist/default/default/extensions/filters/truthy.ts

@@ -0,0 +1,17 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function truthy(
+  context: TemplateContext,
+  condition: boolean,
+  truthy: any,
+  falsey: any,
+) {
+  if (condition) {
+    return truthy;
+  } else {
+    if (typeof falsey != "undefined") {
+      return falsey;
+    }
+  }
+  return condition;
+}

package/dist/default/default/extensions/filters/typescript.ts

@@ -0,0 +1,10 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function to_ts_identifier(context: TemplateContext, identifier: string) {
+  identifier = `${identifier}`;
+  if (/^[_a-z]\w*$/i.test(identifier)) {
+    return identifier;
+  } else {
+    return `["${identifier.replace('"', '\\"')}"]`;
+  }
+}

package/dist/default/default/extensions/filters/unshift.ts

@@ -0,0 +1,10 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function unshift(context: TemplateContext, arr: Array<any>, value: any) {
+  if (Array.isArray(value)) {
+    arr.unshift(...value);
+  } else {
+    arr.unshift(value);
+  }
+  return arr;
+}

package/dist/default/default/extensions/filters/wrap.ts

@@ -0,0 +1,10 @@
+import type { TemplateContext } from "../../../types/template";
+
+export function wrap(
+  context: TemplateContext,
+  value: any,
+  prefix: string,
+  suffix: string,
+) {
+  return `${prefix}${value}${suffix}`;
+}

package/dist/default/default/includes/typescript/get-field-jsdoc.liquid

@@ -0,0 +1,11 @@
+{%- capture output %}
+/**
+  * The `{{ field.name }}` field.
+{%- if field.type.default_value != null %}
+  * @default {{ '{' -}}
+  {{- field.type.default_value | json -}}
+  {{- '}' }}
+{%- endif %}
+  */
+{%- endcapture %}
+{{- output | indent: prefix }}