@resistdesign/voltra 1.1.0 → 1.2.0

package/api/ORM/DataContextService.d.ts

@@ -1,4 +1,5 @@
 import { AsyncReturnValue, DBServiceItemDriver, ListItemResults, ListItemsConfig } from "./ServiceTypes/DBServiceTypes";
+import { TypeStructureUnionType } from "../../common/TypeParsing";
 export declare const DataContextServiceErrorTypes: {
     OPERATION_NOT_ALLOWED: string;
     RELATED_ITEM_SEARCH_NOT_ALLOWED: string;
@@ -14,14 +15,15 @@ export type DataContextField = {
     isContext?: boolean;
     isMultiple?: boolean;
     allowedOperations?: DataContextOperationOptions[];
+    valueOptions?: TypeStructureUnionType[];
     embedded?: boolean;
 };
 export type DataContext<ItemType extends Record<any, any>, UniquelyIdentifyingFieldName extends keyof ItemType> = {
     itemTypeName: string;
     resolvedType?: string;
-    isTypeAlias?: boolean;
     uniquelyIdentifyingFieldName: UniquelyIdentifyingFieldName;
     allowedOperations?: DataContextOperationOptions[];
+    valueOptions?: TypeStructureUnionType[];
     fields: Partial<Record<keyof ItemType, DataContextField>>;
 };
 export type DataContextItemType<DC> = DC extends DataContext<infer T, any> ? T : never;

package/api/ORM/TypeStructureUtils.d.ts

@@ -1,7 +1,17 @@
-import { DataContextMap } from "./DataContextService";
-import { TypeStructureMap } from "../../common/TypeParsing";
+import { DataContext, DataContextField, DataContextMap } from "./DataContextService";
+import { TypeStructure, TypeStructureMap, TypeStructureTagMap } from "../../common/TypeParsing";
+export declare const DataContextFieldTagNames: {
+    uniquelyIdentifyingFieldName: string;
+    allowedOperations: string;
+    virtual: string;
+};
 export declare const getCleanedTagStringValue: (tagValue: any) => string | undefined;
+export declare const typeStructureToDataContextField: (typeStructure: TypeStructure) => DataContextField;
+export declare const mergeDataContextTagMaps: (tagMapA: TypeStructureTagMap, tagMapB: TypeStructureTagMap) => TypeStructureTagMap;
+export declare const typeStructureToDataContext: (typeStructure: TypeStructure, typeStructureMap: TypeStructureMap, defaultUniquelyIdentifyingFieldName?: string, cache?: DataContextMap) => DataContext<any, any>;
+export declare const DEFAULT_UNIQUELY_IDENTIFYING_FIELD_NAME = "id";
 /**
  * Create a {@link DataContextMap} from a {@link TypeStructureMap} generated from TypeScript types.
+ * Types tagged as `@virtual` will not be included in the resulting {@link DataContextMap}.
  * */
-export declare const typeStructureMapToDataContextMap: (typeStructureMap: TypeStructureMap) => DataContextMap;
+export declare const typeStructureMapToDataContextMap: (typeStructureMap: TypeStructureMap, useDefaultUniquelyIdentifyingFieldName?: boolean) => DataContextMap;

package/api/ORM/TypeStructureUtils.js

@@ -1,50 +1,119 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeStructureMapToDataContextMap = exports.getCleanedTagStringValue = void 0;
+exports.typeStructureMapToDataContextMap = exports.DEFAULT_UNIQUELY_IDENTIFYING_FIELD_NAME = exports.typeStructureToDataContext = exports.mergeDataContextTagMaps = exports.typeStructureToDataContextField = exports.getCleanedTagStringValue = exports.DataContextFieldTagNames = void 0;
 const TypeParsing_1 = require("../../common/TypeParsing");
+exports.DataContextFieldTagNames = {
+    uniquelyIdentifyingFieldName: "uniquelyIdentifyingFieldName",
+    allowedOperations: "allowedOperations",
+    virtual: "virtual",
+};
 const getCleanedTagStringValue = (tagValue) => {
     const trimmed = typeof tagValue === "string" ? tagValue.trim() : undefined;
     return !!trimmed ? trimmed : undefined;
 };
 exports.getCleanedTagStringValue = getCleanedTagStringValue;
-/**
- * Create a {@link DataContextMap} from a {@link TypeStructureMap} generated from TypeScript types.
- * */
-const typeStructureMapToDataContextMap = (typeStructureMap) => {
-    const dataContextMap = {};
-    const cleanTypeStructureMap = (0, TypeParsing_1.getCleanTypeStructureMap)(typeStructureMap);
-    Object.entries(cleanTypeStructureMap).forEach(([key, typeStructure]) => {
-        const { namespace, type, content = [] } = typeStructure;
-        const cleanFullTypeName = (0, TypeParsing_1.getCleanType)(type, namespace);
-        const uniquelyIdentifyingFieldName = (0, exports.getCleanedTagStringValue)((0, TypeParsing_1.getTagValue)("uniquelyIdentifyingFieldName", typeStructure));
-        const allowedOperations = (0, exports.getCleanedTagStringValue)((0, TypeParsing_1.getTagValue)("allowedOperations", typeStructure));
+const typeStructureToDataContextField = (typeStructure) => {
+    const { type, literal = false, multiple = false, isUnionType = false, unionTypes = [], } = typeStructure;
+    const allowedOperations = (0, exports.getCleanedTagStringValue)((0, TypeParsing_1.getTagValue)("allowedOperations", typeStructure));
+    const opsList = typeof allowedOperations === "string"
+        ? allowedOperations.split(",").map((o) => o.trim())
+        : undefined;
+    return {
+        typeName: type,
+        isContext: !literal,
+        allowedOperations: opsList,
+        isMultiple: !!multiple,
+        valueOptions: isUnionType ? unionTypes : undefined,
+        embedded: literal,
+    };
+};
+exports.typeStructureToDataContextField = typeStructureToDataContextField;
+const mergeDataContextTagMaps = (tagMapA, tagMapB) => {
+    const { [exports.DataContextFieldTagNames.allowedOperations]: tagMapAAllowedOps } = tagMapA;
+    const { [exports.DataContextFieldTagNames.allowedOperations]: tagMapBAllowedOps } = tagMapB;
+    let mergedTag = Object.assign(Object.assign({}, tagMapA), tagMapB);
+    if (tagMapAAllowedOps && tagMapBAllowedOps) {
+        const { value: tagMapAAllowedOpsValue } = tagMapAAllowedOps;
+        const { value: tagMapBAllowedOpsValue } = tagMapBAllowedOps;
+        if (typeof tagMapAAllowedOpsValue === "string" &&
+            typeof tagMapBAllowedOpsValue === "string") {
+            const mergedAllowedOps = `${tagMapAAllowedOpsValue},${tagMapBAllowedOpsValue}`;
+            mergedTag = Object.assign(Object.assign({}, mergedTag), { [exports.DataContextFieldTagNames.allowedOperations]: {
+                    type: "string",
+                    value: mergedAllowedOps,
+                } });
+        }
+    }
+    return mergedTag;
+};
+exports.mergeDataContextTagMaps = mergeDataContextTagMaps;
+const typeStructureToDataContext = (typeStructure, typeStructureMap, defaultUniquelyIdentifyingFieldName, cache = {}) => {
+    const tsMapCache = {};
+    const { namespace, type, isUnionType, unionTypes = [], content = [], contentNames: { allowed: allowedContentNames = [], disallowed: disallowedContentNames = [], } = {}, } = (0, TypeParsing_1.getCondensedTypeStructure)(typeStructure, typeStructureMap, exports.mergeDataContextTagMaps, tsMapCache);
+    const cleanFullTypeName = (0, TypeParsing_1.getCleanType)(type, namespace);
+    const cachedDataContext = cache[cleanFullTypeName];
+    const hasAllowedContentNames = allowedContentNames.length > 0;
+    const hasDisallowedContentNames = disallowedContentNames.length > 0;
+    if (cachedDataContext) {
+        return cachedDataContext;
+    }
+    else {
+        const uniquelyIdentifyingFieldName = (0, exports.getCleanedTagStringValue)((0, TypeParsing_1.getTagValue)(exports.DataContextFieldTagNames.uniquelyIdentifyingFieldName, typeStructure));
+        const allowedOperations = (0, exports.getCleanedTagStringValue)((0, TypeParsing_1.getTagValue)(exports.DataContextFieldTagNames.allowedOperations, typeStructure));
         const uuidFieldName = typeof uniquelyIdentifyingFieldName === "string"
             ? uniquelyIdentifyingFieldName.trim()
-            : undefined;
+            : defaultUniquelyIdentifyingFieldName;
         const opsList = allowedOperations
             ? allowedOperations.split(",").map((o) => o.trim())
             : undefined;
-        dataContextMap[key] = {
-            itemTypeName: key,
+        const newDataContext = {
+            itemTypeName: cleanFullTypeName,
             resolvedType: type,
-            isTypeAlias: !(cleanFullTypeName === key),
             uniquelyIdentifyingFieldName: uuidFieldName,
             allowedOperations: opsList,
-            fields: content.reduce((acc, subType) => {
-                const { name, type, literal = false, multiple = false } = subType;
-                const subAO = (0, exports.getCleanedTagStringValue)((0, TypeParsing_1.getTagValue)("allowedOperations", subType));
-                const subOpsList = typeof subAO === "string"
-                    ? subAO.split(",").map((o) => o.trim())
-                    : undefined;
-                return Object.assign(Object.assign({}, acc), { [name]: {
-                        typeName: type,
-                        isContext: !literal,
-                        allowedOperations: subOpsList,
-                        embedded: literal,
-                        isMultiple: multiple,
-                    } });
-            }, {}),
+            valueOptions: isUnionType ? unionTypes : undefined,
+            fields: {},
         };
+        for (const field of content) {
+            const { name: fieldName } = field;
+            // IMPORTANT: Use `contentNames` (Pick/Omit) to limit fields.
+            const fieldIsAllowed = hasAllowedContentNames
+                ? allowedContentNames.includes(fieldName)
+                : hasDisallowedContentNames
+                    ? !disallowedContentNames.includes(fieldName)
+                    : true;
+            if (fieldIsAllowed) {
+                const { literal: mappedFieldTypeLiteral = false, unionTypes: mappedFieldTypeUnionTypes = [], } = (0, TypeParsing_1.getCondensedTypeStructure)(field, typeStructureMap, exports.mergeDataContextTagMaps, tsMapCache);
+                const isUnionType = mappedFieldTypeLiteral && mappedFieldTypeUnionTypes.length > 0;
+                newDataContext.fields[fieldName] = (0, exports.typeStructureToDataContextField)(Object.assign(Object.assign({}, field), { isUnionType, unionTypes: isUnionType ? mappedFieldTypeUnionTypes : undefined }));
+            }
+        }
+        cache[cleanFullTypeName] = newDataContext;
+        return newDataContext;
+    }
+};
+exports.typeStructureToDataContext = typeStructureToDataContext;
+exports.DEFAULT_UNIQUELY_IDENTIFYING_FIELD_NAME = "id";
+/**
+ * Create a {@link DataContextMap} from a {@link TypeStructureMap} generated from TypeScript types.
+ * Types tagged as `@virtual` will not be included in the resulting {@link DataContextMap}.
+ * */
+const typeStructureMapToDataContextMap = (typeStructureMap, useDefaultUniquelyIdentifyingFieldName = true) => {
+    const dataContextMap = {};
+    Object.entries(typeStructureMap).forEach(([_key, typeStructure]) => {
+        const { namespace, type } = typeStructure;
+        const isVirtual = (0, TypeParsing_1.getTagValue)(exports.DataContextFieldTagNames.virtual, typeStructure);
+        const cleanFullTypeName = (0, TypeParsing_1.getCleanType)(type, namespace);
+        // TODO: Losing pick/omit info here, because `type` is being used as the key.
+        // TODO: May need to keep the pick/omit types but mark them as not real database tables.
+        const existingDataContext = dataContextMap[cleanFullTypeName];
+        if (!isVirtual) {
+            dataContextMap[cleanFullTypeName] = !!existingDataContext
+                ? existingDataContext
+                : (0, exports.typeStructureToDataContext)(typeStructure, typeStructureMap, useDefaultUniquelyIdentifyingFieldName
+                    ? exports.DEFAULT_UNIQUELY_IDENTIFYING_FIELD_NAME
+                    : undefined, dataContextMap);
+        }
     });
     return dataContextMap;
 };

package/common/TypeParsing/TypeParsing.js

@@ -17,6 +17,54 @@ const SUPPORTED_TYPE_REFERENCE_FEATURES = {
     PICK: "Pick",
     OMIT: "Omit",
 };
+const UNION_TYPE_SEPARATOR = "|";
+const STRING_LITERAL_TYPE_DETECTION_REGEX = /(^'[\s\S]*'$)|(^"[\s\S]*"$)/gim;
+const typeIsUnionType = (type = "") => type.includes(UNION_TYPE_SEPARATOR);
+const typeIsBooleanLiteral = (type = "") => type === "true" || type === "false";
+const getCleanBooleanLiteral = (type = "") => type === "true";
+const typeIsStringLiteral = (type = "") => type.match(STRING_LITERAL_TYPE_DETECTION_REGEX) !== null;
+const getCleanStringLiteral = (type = "") => type.replace(/['"]/gim, "");
+const typeIsNumberLiteral = (type = "") => type !== "" && !isNaN(Number(type));
+const getCleanNumberLiteral = (type = "") => Number(type);
+const getUnionTypes = (type = "") => {
+    const cleanOverallType = type
+        .trim()
+        .replace(/^\(/gim, "")
+        .replace(/\)$/gim, "");
+    const typeParts = cleanOverallType.split(UNION_TYPE_SEPARATOR);
+    const cleanTypeParts = typeParts.map((t) => t.trim());
+    const parsedUnionTypes = cleanTypeParts.map((t) => {
+        if (typeIsBooleanLiteral(t)) {
+            return {
+                type: "boolean",
+                literal: true,
+                value: getCleanBooleanLiteral(t),
+            };
+        }
+        else if (typeIsStringLiteral(t)) {
+            return {
+                type: "string",
+                literal: true,
+                value: getCleanStringLiteral(t),
+            };
+        }
+        else if (typeIsNumberLiteral(t)) {
+            return {
+                type: "number",
+                literal: true,
+                value: getCleanNumberLiteral(t),
+            };
+        }
+        else {
+            return {
+                type: t,
+                literal: false,
+                value: t,
+            };
+        }
+    });
+    return parsedUnionTypes;
+};
 const TYPE_HANDLING_MAP = {
     [typescript_1.SyntaxKind.TypeLiteral]: (name, typeNode, { parentName, namespace } = {}) => {
         const content = [];
@@ -57,12 +105,22 @@ const TYPE_HANDLING_MAP = {
     },
     [typescript_1.SyntaxKind.UnionType]: (name, typeNode, { parentName, namespace } = {}) => {
         const { types = [] } = typeNode;
+        const typeList = types.map((t) => {
+            const { type: parsedTypeName } = parseType(name, t, {
+                parentName,
+                namespace,
+            });
+            return parsedTypeName;
+        });
+        const unionTypes = getUnionTypes(typeList.join(UNION_TYPE_SEPARATOR));
         return {
             namespace,
             name,
             type: parentName ? `${parentName}.${name}` : name,
-            varietyType: true,
-            content: types.map((t) => parseType(name, t, { parentName, namespace })),
+            isUnionType: true,
+            unionTypes,
+            literal: unionTypes.reduce((acc, { literal }) => acc && literal, true),
+            content: [],
         };
     },
     [typescript_1.SyntaxKind.IntersectionType]: (name, typeNode, { parentName, namespace } = {}) => {
@@ -167,10 +225,15 @@ const parseType = (name, typeNode, { parentName, namespace } = {}) => {
         return Object.assign({ comments: [...comments, ...handledComments], tags: Object.assign(Object.assign({}, tags), handledTags) }, otherHandledTypeProps);
     }
     else {
+        const type = typeNode.getText();
+        const typeIsUnion = typeIsUnionType(type);
+        const unionTypes = typeIsUnion ? getUnionTypes(type) : undefined;
         return {
             namespace,
             name,
-            type: typeNode.getText(),
+            type,
+            isUnionType: typeIsUnion,
+            unionTypes,
             literal: true,
             comments,
             tags,

package/common/TypeParsing/TypeUtils.d.ts

@@ -1,12 +1,22 @@
+export type TypeStructureTagMap = Record<string, {
+    type?: string | undefined;
+    value?: string | boolean | undefined;
+}>;
+export type TypeStructureUnionType = {
+    type: string;
+    literal: boolean;
+    value: any;
+};
 export type TypeStructure = {
     namespace?: string;
     name: string;
     typeAlias?: string;
     type: string;
+    isUnionType?: boolean;
+    unionTypes?: TypeStructureUnionType[];
     literal?: boolean;
     readonly?: boolean;
     optional?: boolean;
-    varietyType?: boolean;
     comboType?: boolean;
     multiple?: boolean | number;
     contentNames?: {
@@ -15,10 +25,7 @@ export type TypeStructure = {
     };
     content?: TypeStructure[];
     comments?: string[];
-    tags?: Record<string, {
-        type?: string | undefined;
-        value?: string | boolean | undefined;
-    }>;
+    tags?: TypeStructureTagMap;
 };
 export type TypeStructureMap = Record<string, TypeStructure>;
 export type TypeStructureControllerItemOrdering = {
@@ -54,6 +61,8 @@ export declare const getCleanType: (typeValue?: string, namespace?: string) => s
 export declare const getTypeStructureWithFilteredContent: ({ allowed, disallowed }: TypeStructure["contentNames"], typeStructure: TypeStructure) => TypeStructure;
 export declare const getTypeStructureByName: <TypeStructureMapType extends TypeStructureMap, TypeStructureName extends keyof TypeStructureMapType>(name: TypeStructureName, map: TypeStructureMapType) => TypeStructureMapType[TypeStructureName];
 export declare const getMergedTypeStructure: (...typeStructures: TypeStructure[]) => TypeStructure | undefined;
+export declare const getUniqueStringArray: (arr: string[]) => string[];
+export declare const getCondensedTypeStructure: (typeStructure: TypeStructure, typeStructureMap: TypeStructureMap, mergeTagMaps?: ((tagMapA: TypeStructureTagMap, tagMapB: TypeStructureTagMap) => TypeStructureTagMap) | undefined, cache?: TypeStructureMap) => TypeStructure;
 export declare const getCleanTypeStructure: (typeStructure: TypeStructure, typeStructureMap?: TypeStructureMap) => TypeStructure;
 export declare const getCleanTypeStructureMap: (typeStructureMap: TypeStructureMap) => TypeStructureMap;
 export declare const getTypeStructureByPath: (path: (string | number)[], typeStructure: TypeStructure, typeStructureMap: TypeStructureMap) => TypeStructure;

package/common/TypeParsing/TypeUtils.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueLabel = exports.getItemNameKeys = exports.getTagValues = exports.getTagValue = exports.getItemName = exports.getCleanPrimitiveStringValue = exports.TAG_TYPES = exports.getDefaultItemForTypeStructure = exports.getTypeStructureIsPrimitive = exports.getTypeStructureByPath = exports.getCleanTypeStructureMap = exports.getCleanTypeStructure = exports.getMergedTypeStructure = exports.getTypeStructureByName = exports.getTypeStructureWithFilteredContent = exports.getCleanType = exports.combineTypeStructures = exports.identifyValueType = void 0;
-const NOOP = () => undefined;
+exports.getValueLabel = exports.getItemNameKeys = exports.getTagValues = exports.getTagValue = exports.getItemName = exports.getCleanPrimitiveStringValue = exports.TAG_TYPES = exports.getDefaultItemForTypeStructure = exports.getTypeStructureIsPrimitive = exports.getTypeStructureByPath = exports.getCleanTypeStructureMap = exports.getCleanTypeStructure = exports.getCondensedTypeStructure = exports.getUniqueStringArray = exports.getMergedTypeStructure = exports.getTypeStructureByName = exports.getTypeStructureWithFilteredContent = exports.getCleanType = exports.combineTypeStructures = exports.identifyValueType = void 0;
 const identifyValueType = (value, typeStructureVariety = []) => {
     var _a;
     const typeStructureMap = typeStructureVariety.reduce((acc, typeStructure) => {
@@ -87,6 +86,72 @@ const getMergedTypeStructure = (...typeStructures) => {
     return mergedTypeStructure;
 };
 exports.getMergedTypeStructure = getMergedTypeStructure;
+const getUniqueStringArray = (arr) => arr.filter((item, index) => arr.indexOf(item) === index);
+exports.getUniqueStringArray = getUniqueStringArray;
+const getCondensedTypeStructure = (typeStructure, typeStructureMap, mergeTagMaps, cache = {}) => {
+    const { namespace, type, typeAlias, literal = false } = typeStructure;
+    const cleanFullTypeName = (0, exports.getCleanType)(type, namespace);
+    let condensedTypeStructure = cache[cleanFullTypeName];
+    if (!condensedTypeStructure) {
+        if (literal) {
+            condensedTypeStructure = typeStructure;
+        }
+        else {
+            const mappedType = !!typeAlias
+                ? typeStructureMap[typeAlias]
+                : typeStructureMap[cleanFullTypeName];
+            const { comboType = false, isUnionType = false, content = [], } = mappedType;
+            if (mappedType) {
+                if (isUnionType) {
+                    condensedTypeStructure = mappedType;
+                }
+                else if (comboType) {
+                    let mergedType = Object.assign(Object.assign({}, mappedType), { 
+                        // TRICKY: Reset this because we don't want to keep type references, just get their fields.
+                        content: [] });
+                    for (const subType of content) {
+                        const condensedSubType = (0, exports.getCondensedTypeStructure)(subType, typeStructureMap, mergeTagMaps, cache);
+                        const { contentNames: { allowed: subTypeAllowedContentNames, disallowed: subTypeDisallowedContentNames, } = {}, content: subTypeContent = [], comments: subTypeComments = [], tags: subTypeTags = {}, } = condensedSubType;
+                        const { contentNames: { allowed: mergedTypeAllowedContentNames, disallowed: mergedTypeDisallowedContentNames, } = {}, content: mergedTypeContent = [], comments: mergedTypeComments = [], tags: mergedTypeTags = {}, } = mergedType;
+                        const newMergedTypeAllowedContentNames = !!subTypeAllowedContentNames || !!mergedTypeAllowedContentNames
+                            ? (0, exports.getUniqueStringArray)([
+                                ...(mergedTypeAllowedContentNames || []),
+                                ...(subTypeAllowedContentNames || []),
+                            ])
+                            : undefined;
+                        const newMergedTypeDisallowedContentNames = !!subTypeDisallowedContentNames ||
+                            !!mergedTypeDisallowedContentNames
+                            ? (0, exports.getUniqueStringArray)([
+                                ...(mergedTypeDisallowedContentNames || []),
+                                ...(subTypeDisallowedContentNames || []),
+                            ])
+                            : undefined;
+                        const newMergedTypeContentNames = newMergedTypeAllowedContentNames ||
+                            newMergedTypeDisallowedContentNames
+                            ? {
+                                allowed: newMergedTypeAllowedContentNames,
+                                disallowed: newMergedTypeDisallowedContentNames,
+                            }
+                            : undefined;
+                        mergedType = Object.assign(Object.assign(Object.assign({}, mergedType), subType), { contentNames: newMergedTypeContentNames, content: [...mergedTypeContent, ...subTypeContent], comments: [...mergedTypeComments, ...subTypeComments], tags: !!mergeTagMaps
+                                ? mergeTagMaps(mergedTypeTags, subTypeTags)
+                                : Object.assign(Object.assign({}, mergedTypeTags), subTypeTags) });
+                    }
+                    condensedTypeStructure = mergedType;
+                }
+                else {
+                    condensedTypeStructure = (0, exports.getCondensedTypeStructure)(mappedType, typeStructureMap, mergeTagMaps, cache);
+                }
+            }
+            else {
+                condensedTypeStructure = typeStructure;
+            }
+        }
+    }
+    cache[cleanFullTypeName] = condensedTypeStructure;
+    return condensedTypeStructure;
+};
+exports.getCondensedTypeStructure = getCondensedTypeStructure;
 const getCleanTypeStructure = (typeStructure, typeStructureMap) => {
     const { namespace, name, type, typeAlias, literal, comments = [], tags = {}, } = typeStructure;
     if (literal) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resistdesign/voltra",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "With our powers combined!",
   "homepage": "https://voltra.app",
   "repository": "git@github.com:resistdesign/voltra.git",