@cododel/alto 0.1.5 → 0.1.6

package/dist/default/default/templates/default/types.ts.njk

@@ -0,0 +1,134 @@
+{% block header %}
+/**
+ * This file is automatically generated by the `@indirectus/cli` package.
+ * Follow the package's instruction to update this file with the latest schema.
+ */
+{% endblock %}
+
+{% block imports %}
+import type * as Directus from "@directus/sdk";
+
+{% endblock %}
+
+export namespace Types {
+{% block types %}
+  // Internal
+  export type Nullable<T> = T | null;
+  export type Optional<T> = Nullable<T>;
+  export type UnknownType<T> = T | unknown;
+  export type PrimaryKey<T> = T;
+
+  // Numbers
+  export type BigInteger = number;
+  export type Decimal = number;
+  export type Float = number;
+  export type Integer = number;
+  export type Number = number;
+
+  // Buffers
+  export type Binary = string;
+  export type String = string;
+  export type Text = string;
+
+  // Date & Time
+  export type Date = string | globalThis.Date;
+  export type DateTime = string | globalThis.Date;
+
+  // Geometry
+  export namespace Geometry {
+    export type LineString = any;
+    export type MultiLineString = any;
+    export type MultiPoint = any;
+    export type MultiPolygon = any;
+    export type Point = any;
+    export type Polygon = any;
+  }
+
+  // Complex
+  export type JSON = any;
+  export type JSONSchema = any;
+
+  // Others
+  export type UUID = string;
+  export type Boolean = boolean;
+  export type Enum = string;
+
+{% endblock %}
+}
+
+/**
+ * All collection types.
+ */
+export namespace Collections {
+
+{% for collection in registry.collections | skip_collections(skipCollections) -%}
+{% if collection.is_system %}
+
+{%- set field_count = collection.fields | only_custom_fields | length -%}
+  {% filter comment -%}
+  The resolved {{ collection.name | to_collection_text }} collection type.
+  {% endfilter %}
+  export type {{ collection.name | to_collection_name }} = Directus.{{ collection.name | to_collection_name }}<System>;
+{% endif %}
+{% endfor %}
+
+{% for collection in registry.collections -%}
+{% if not collection.is_system %}
+  /**
+   * The {{ collection.name | space_case | lower_case }} collection.
+   */
+  export interface {{ collection.name | pascal_case }} {
+{%- for field in collection.fields %}
+{%- set type = field | to_ts_type -%}
+{%- if type != 'never' %}
+  {{ field.name | to_ts_identifier }}: {{ type }};
+{%- endif -%}
+{%- endfor %}
+  }
+{% endif %}
+{% endfor %}
+}
+
+/**
+ * System schema extensions.
+ */
+
+export interface System {
+
+{% for collection in registry.collections | skip_collections(skipCollections) -%}
+{% if collection.is_system %}
+
+  {% filter comment -%}
+  The definition for the {{ collection.name | to_collection_text }} system collection.
+  {% endfilter %}
+  {{ collection.name }}: {
+    {%- for field in collection.fields | only_custom_fields %}
+      {%- set type = field | to_ts_type -%}
+      {%- if type != 'never' %}
+        {{ field.name | to_ts_identifier }}: {{ type }};
+      {%- endif -%}
+    {%- endfor %}
+  }{{ "" if collection.is_singleton else "[]" }};
+
+{% endif %}
+{% endfor %}
+
+}
+
+/**
+ * Schema definition.
+ */
+export interface Schema extends System {
+{% for collection in registry.collections -%}
+  {% if not collection.is_system %}
+  {% set suffix = "" if collection.is_singleton else "[]" %}
+  /**
+   * The {{ collection.name | to_collection_text }} collection.
+   */
+  {{ collection.name | to_ts_identifier }}: Collections.{{ collection.name | pascal_case }}{{ suffix }};
+  {% endif %}
+{% endfor %}
+}
+
+
+

package/dist/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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);
+}