@cheetah.js/orm 0.1.146 → 0.1.149

package/dist/SqlBuilder.js

@@ -5,6 +5,7 @@ const entities_1 = require("./domain/entities");
 const orm_1 = require("./orm");
 const value_processor_1 = require("./utils/value-processor");
 const sql_condition_builder_1 = require("./query/sql-condition-builder");
+const sql_subquery_builder_1 = require("./query/sql-subquery-builder");
 const model_transformer_1 = require("./query/model-transformer");
 const sql_column_manager_1 = require("./query/sql-column-manager");
 const sql_join_manager_1 = require("./query/sql-join-manager");
@@ -27,6 +28,8 @@ class SqlBuilder {
             return this.joinManager.applyJoin(relationship, value, alias);
         };
         this.conditionBuilder = new sql_condition_builder_1.SqlConditionBuilder(this.entityStorage, applyJoinWrapper, this.statements);
+        const subqueryBuilder = new sql_subquery_builder_1.SqlSubqueryBuilder(this.entityStorage, () => this.conditionBuilder);
+        this.conditionBuilder.setSubqueryBuilder(subqueryBuilder);
         this.joinManager = new sql_join_manager_1.SqlJoinManager(this.entityStorage, this.statements, this.entity, this.model, this.driver, this.logger, this.conditionBuilder, this.columnManager, this.modelTransformer, () => this.originalColumns, this.getAlias.bind(this));
     }
     initializeCacheManager() {

package/dist/decorators/unique.decorator.d.ts

@@ -0,0 +1,9 @@
+export type UniqueDefinition = {
+    name: string;
+    properties: string[];
+};
+type UniqueOptions<T> = {
+    properties: (keyof T)[];
+} | (keyof T)[] | undefined;
+export declare function Unique<T>(options?: UniqueOptions<T>): ClassDecorator & PropertyDecorator;
+export {};

package/dist/decorators/unique.decorator.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unique = Unique;
+const core_1 = require("@cheetah.js/core");
+function getCtor(target) {
+    return typeof target === "function" ? target : target.constructor;
+}
+function buildFromOptions(options) {
+    const props = Array.isArray(options) ? options : options?.properties;
+    if (!props || props.length === 0) {
+        return null;
+    }
+    const keys = props;
+    return {
+        name: `${keys.join('_')}_unique`,
+        properties: keys,
+    };
+}
+function buildFromProperty(propertyKey) {
+    const name = String(propertyKey);
+    return {
+        name: `${name}_unique`,
+        properties: [name],
+    };
+}
+function resolveUnique(options, propertyKey) {
+    const fromOptions = buildFromOptions(options);
+    if (fromOptions) {
+        return fromOptions;
+    }
+    if (!propertyKey) {
+        throw new Error("@Unique on class requires properties option");
+    }
+    return buildFromProperty(propertyKey);
+}
+function Unique(options) {
+    return (target, propertyKey) => {
+        const ctor = getCtor(target);
+        const uniques = [...(core_1.Metadata.get("uniques", ctor) || [])];
+        const unique = resolveUnique(options, propertyKey);
+        uniques.push(unique);
+        core_1.Metadata.set("uniques", uniques, ctor);
+    };
+}

package/dist/domain/entities.d.ts

@@ -1,5 +1,5 @@
 import { PropertyOptions } from "../decorators/property.decorator";
-import { Relationship, SnapshotIndexInfo, SnapshotTable } from "../driver/driver.interface";
+import { Relationship, SnapshotIndexInfo, SnapshotTable, SnapshotUniqueInfo } from "../driver/driver.interface";
 export type Property = {
     options: PropertyOptions;
     type: Function;
@@ -10,6 +10,7 @@ export type Options = {
     };
     hideProperties: string[];
     indexes?: SnapshotIndexInfo[];
+    uniques?: SnapshotUniqueInfo[];
     relations: Relationship<any>[];
     tableName: string;
     hooks?: {

package/dist/domain/entities.js

@@ -77,6 +77,31 @@ function buildIndexWhere(where, columnMap) {
     const builder = new index_condition_builder_1.IndexConditionBuilder(columnMap);
     return builder.build(where);
 }
+function mapUniqueDefinitions(uniques, entityName, columnMap) {
+    return uniques.map((unique) => toSnapshotUnique(unique, entityName, columnMap));
+}
+function toSnapshotUnique(unique, entityName, columnMap) {
+    const columns = resolveUniqueColumns(unique, columnMap);
+    const uniqueName = resolveUniqueName(unique.name, entityName, columns);
+    return {
+        table: entityName,
+        uniqueName,
+        columnName: columns.join(","),
+    };
+}
+function resolveUniqueColumns(unique, columnMap) {
+    return unique.properties.map((propName) => resolveUniqueColumn(propName, columnMap));
+}
+function resolveUniqueColumn(propName, columnMap) {
+    const mapped = columnMap[propName];
+    if (mapped) {
+        return mapped;
+    }
+    return (0, utils_1.toSnakeCase)(propName);
+}
+function resolveUniqueName(name, entityName, columns) {
+    return `${columns.join("_")}_unique`;
+}
 let EntityStorage = EntityStorage_1 = class EntityStorage {
     constructor() {
         this.entities = new Map();
@@ -85,6 +110,7 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
     add(entity, properties, relations, hooks) {
         const entityName = entity.options?.tableName || (0, utils_1.toSnakeCase)(entity.target.name);
         const indexes = core_1.Metadata.get("indexes", entity.target) || [];
+        const uniques = core_1.Metadata.get("uniques", entity.target) || [];
         const columnMap = buildIndexColumnMap(properties, relations);
         this.entities.set(entity.target, {
             properties: properties,
@@ -93,6 +119,7 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
                 .map(([key]) => key),
             relations,
             indexes: mapIndexDefinitions(indexes, entityName, columnMap),
+            uniques: mapUniqueDefinitions(uniques, entityName, columnMap),
             hooks,
             tableName: entityName,
             ...entity.options,
@@ -116,6 +143,7 @@ let EntityStorage = EntityStorage_1 = class EntityStorage {
             tableName: values.tableName,
             schema: values.schema || "public",
             indexes: values.indexes || [],
+            uniques: values.uniques || [],
             columns: this.snapshotColumns(values),
         };
     }

package/dist/driver/bun-mysql.driver.d.ts

@@ -26,6 +26,13 @@ export declare class BunMysqlDriver extends BunDriverBase implements DriverInter
         name: string;
         properties?: string[];
     }, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
     getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;

package/dist/driver/bun-mysql.driver.js

@@ -141,6 +141,17 @@ class BunMysqlDriver extends bun_driver_base_1.BunDriverBase {
     getDropIndex(index, schema, tableName) {
         return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${index.name}\`;`;
     }
+    getCreateUniqueConstraint(unique, schema, tableName) {
+        const properties = unique.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Unique properties are required.");
+        }
+        const columns = properties.map((prop) => `\`${prop}\``).join(', ');
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` ADD CONSTRAINT \`${unique.name}\` UNIQUE (${columns});`;
+    }
+    getDropUniqueConstraint(unique, schema, tableName) {
+        return `ALTER TABLE \`${schema}\`.\`${tableName}\` DROP INDEX \`${unique.name}\`;`;
+    }
     getAlterTableType(schema, tableName, colName, colDiff) {
         return `ALTER TABLE \`${schema}\`.\`${tableName}\` MODIFY COLUMN \`${colName}\` ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
     }

package/dist/driver/bun-pg.driver.d.ts

@@ -25,6 +25,13 @@ export declare class BunPgDriver extends BunDriverBase implements DriverInterfac
         name: string;
         properties?: string[];
     }, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
     getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;

package/dist/driver/bun-pg.driver.js

@@ -114,6 +114,17 @@ class BunPgDriver extends bun_driver_base_1.BunDriverBase {
     getDropIndex(index, schema, tableName) {
         return this.getDropConstraint(index, schema, tableName);
     }
+    getCreateUniqueConstraint(unique, schema, tableName) {
+        const properties = unique.properties || [];
+        if (properties.length === 0) {
+            throw new Error("Unique properties are required.");
+        }
+        const columns = properties.map((prop) => `"${prop}"`).join(', ');
+        return `ALTER TABLE "${schema}"."${tableName}" ADD CONSTRAINT "${unique.name}" UNIQUE (${columns});`;
+    }
+    getDropUniqueConstraint(unique, schema, tableName) {
+        return this.getDropConstraint(unique, schema, tableName);
+    }
     getAlterTableType(schema, tableName, colName, colDiff) {
         return `ALTER TABLE "${schema}"."${tableName}" ALTER COLUMN "${colName}" TYPE ${colDiff.colType}${colDiff.colLength ? `(${colDiff.colLength})` : ''};`;
     }

package/dist/driver/driver.interface.d.ts

@@ -20,6 +20,8 @@ export interface DriverInterface {
     getAddColumn(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff, colDiffInstructions: string[]): void;
     getDropColumn(colDiffInstructions: string[], schema: string | undefined, tableName: string, colName: string): void;
     getDropIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: UniqueStatement, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: UniqueStatement, schema: string | undefined, tableName: string): string;
     getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
     getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
@@ -136,6 +138,7 @@ export type SnapshotTable = {
     schema?: string;
     columns: ColumnsInfo[];
     indexes: SnapshotIndexInfo[];
+    uniques?: SnapshotUniqueInfo[];
     foreignKeys?: ForeignKeyInfo[];
 };
 export type SnapshotIndexInfo = {
@@ -144,11 +147,20 @@ export type SnapshotIndexInfo = {
     columnName: string;
     where?: string;
 };
+export type SnapshotUniqueInfo = {
+    table: string;
+    uniqueName: string;
+    columnName: string;
+};
 export type IndexStatement = {
     name: string;
     properties?: string[];
     where?: string;
 };
+export type UniqueStatement = {
+    name: string;
+    properties?: string[];
+};
 export type ForeignKeyInfo = {
     referencedTableName: string;
     referencedColumnName: string;
@@ -236,6 +248,8 @@ export type OperatorMap<T> = {
     $lt?: ExpandScalar<T>;
     $lte?: ExpandScalar<T>;
     $like?: string;
+    $exists?: FilterQuery<ExpandProperty<T>>;
+    $nexists?: FilterQuery<ExpandProperty<T>>;
 };
 export type ExcludeFunctions<T, K extends keyof T> = T[K] extends Function ? never : K extends symbol ? never : K;
 export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp | Uint8Array | {

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from './decorators/property.decorator';
 export * from './decorators/primary-key.decorator';
 export * from './decorators/one-many.decorator';
 export * from './decorators/index.decorator';
+export * from './decorators/unique.decorator';
 export * from './decorators/event-hook.decorator';
 export * from './decorators/enum.decorator';
 export * from './decorators/computed.decorator';

package/dist/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./decorators/property.decorator"), exports);
 __exportStar(require("./decorators/primary-key.decorator"), exports);
 __exportStar(require("./decorators/one-many.decorator"), exports);
 __exportStar(require("./decorators/index.decorator"), exports);
+__exportStar(require("./decorators/unique.decorator"), exports);
 __exportStar(require("./decorators/event-hook.decorator"), exports);
 __exportStar(require("./decorators/enum.decorator"), exports);
 __exportStar(require("./decorators/computed.decorator"), exports);

package/dist/query/sql-condition-builder.d.ts

@@ -1,5 +1,6 @@
 import { FilterQuery, Relationship, Statement } from '../driver/driver.interface';
 import { EntityStorage } from '../domain/entities';
+import { SqlSubqueryBuilder } from './sql-subquery-builder';
 type ApplyJoinCallback = (relationship: Relationship<any>, value: FilterQuery<any>, alias: string) => string;
 export declare class SqlConditionBuilder<T> {
     private entityStorage;
@@ -7,10 +8,13 @@ export declare class SqlConditionBuilder<T> {
     private statements;
     private readonly OPERATORS;
     private lastKeyNotOperator;
+    private subqueryBuilder?;
     constructor(entityStorage: EntityStorage, applyJoinCallback: ApplyJoinCallback, statements: Statement<T>);
+    setSubqueryBuilder(subqueryBuilder: SqlSubqueryBuilder): void;
     build(condition: FilterQuery<T>, alias: string, model: Function): string;
     private processConditions;
     private processEntry;
+    private hasExistsOperator;
     private handleRelationship;
     private handleScalarValue;
     private handleObjectValue;
@@ -39,6 +43,7 @@ export declare class SqlConditionBuilder<T> {
     private isLogicalOperator;
     private extractLogicalOperator;
     private trackLastNonOperatorKey;
+    private buildExistsCondition;
     private resolveColumnName;
     private resolveRelationColumn;
 }

package/dist/query/sql-condition-builder.js

@@ -8,15 +8,19 @@ class SqlConditionBuilder {
         this.entityStorage = entityStorage;
         this.applyJoinCallback = applyJoinCallback;
         this.statements = statements;
-        this.OPERATORS = ['$eq', '$ne', '$in', '$nin', '$like', '$gt', '$gte', '$lt', '$lte', '$and', '$or'];
+        this.OPERATORS = ['$eq', '$ne', '$in', '$nin', '$like', '$gt', '$gte', '$lt', '$lte', '$and', '$or', '$exists', '$nexists'];
         this.lastKeyNotOperator = '';
     }
+    setSubqueryBuilder(subqueryBuilder) {
+        this.subqueryBuilder = subqueryBuilder;
+    }
     build(condition, alias, model) {
         const sqlParts = this.processConditions(condition, alias, model);
         if (sqlParts.length === 0) {
             return '';
         }
-        return this.wrapWithLogicalOperator(sqlParts, 'AND');
+        const result = this.wrapWithLogicalOperator(sqlParts, 'AND');
+        return result;
     }
     processConditions(condition, alias, model) {
         const sqlParts = [];
@@ -32,7 +36,7 @@ class SqlConditionBuilder {
     processEntry(key, value, alias, model) {
         this.trackLastNonOperatorKey(key, model);
         const relationship = this.findRelationship(key, model);
-        if (relationship) {
+        if (relationship && !this.hasExistsOperator(value)) {
             return this.handleRelationship(relationship, value, alias);
         }
         if (this.isScalarValue(value)) {
@@ -43,6 +47,9 @@ class SqlConditionBuilder {
         }
         return this.handleObjectValue(key, value, alias, model);
     }
+    hasExistsOperator(value) {
+        return typeof value === 'object' && value !== null && ('$exists' in value || '$nexists' in value);
+    }
     handleRelationship(relationship, value, alias) {
         const sql = this.applyJoinCallback(relationship, value, alias);
         if (this.statements.strategy === 'joined') {
@@ -100,6 +107,10 @@ class SqlConditionBuilder {
             case '$and':
             case '$or':
                 return this.buildNestedLogicalCondition(operator, value, alias, model);
+            case '$exists':
+                return this.buildExistsCondition(key, value, alias, model, false);
+            case '$nexists':
+                return this.buildExistsCondition(key, value, alias, model, true);
             default:
                 return '';
         }
@@ -202,6 +213,21 @@ class SqlConditionBuilder {
             this.lastKeyNotOperator = key;
         }
     }
+    buildExistsCondition(key, filters, alias, model, negate) {
+        const relationship = this.findRelationship(key, model);
+        if (!relationship) {
+            const entity = this.entityStorage.get(model);
+            const availableRelations = entity?.relations
+                ?.map((r) => r.propertyKey)
+                .join(', ') || 'none';
+            throw new Error(`Cannot use $${negate ? 'nexists' : 'exists'} on non-relationship field '${key}'. ` +
+                `Available relationships: ${availableRelations}`);
+        }
+        if (!this.subqueryBuilder) {
+            throw new Error('SqlSubqueryBuilder not initialized. This is an internal error.');
+        }
+        return this.subqueryBuilder.buildExistsSubquery(relationship, filters, alias, negate, model);
+    }
     resolveColumnName(property, model) {
         if (property.startsWith('$')) {
             return property;

package/dist/query/sql-subquery-builder.d.ts

@@ -0,0 +1,20 @@
+import { FilterQuery, Relationship } from '../driver/driver.interface';
+import { EntityStorage } from '../domain/entities';
+import { SqlConditionBuilder } from './sql-condition-builder';
+export declare class SqlSubqueryBuilder {
+    private entityStorage;
+    private getConditionBuilder;
+    private aliasCounter;
+    constructor(entityStorage: EntityStorage, getConditionBuilder: () => SqlConditionBuilder<any>);
+    buildExistsSubquery(relationship: Relationship<any>, filters: FilterQuery<any>, outerAlias: string, negate: boolean, outerModel?: Function): string;
+    private buildSubquery;
+    private buildWhereClause;
+    private buildCorrelation;
+    private getOuterPrimaryKey;
+    private buildFilterConditions;
+    private combineConditions;
+    private resolveTableName;
+    private generateAlias;
+    private getFkKey;
+    private getRelatedPrimaryKey;
+}

package/dist/query/sql-subquery-builder.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlSubqueryBuilder = void 0;
+class SqlSubqueryBuilder {
+    constructor(entityStorage, getConditionBuilder) {
+        this.entityStorage = entityStorage;
+        this.getConditionBuilder = getConditionBuilder;
+        this.aliasCounter = 1;
+    }
+    buildExistsSubquery(relationship, filters, outerAlias, negate, outerModel) {
+        const prefix = negate ? 'NOT EXISTS' : 'EXISTS';
+        const subquery = this.buildSubquery(relationship, filters, outerAlias, outerModel);
+        return `${prefix} (${subquery})`;
+    }
+    buildSubquery(relationship, filters, outerAlias, outerModel) {
+        const subqueryAlias = this.generateAlias();
+        const tableName = this.resolveTableName(relationship);
+        const whereClause = this.buildWhereClause(relationship, filters, outerAlias, subqueryAlias, outerModel);
+        return `SELECT 1 FROM ${tableName} ${subqueryAlias} WHERE ${whereClause}`;
+    }
+    buildWhereClause(relationship, filters, outerAlias, subqueryAlias, outerModel) {
+        const correlation = this.buildCorrelation(relationship, outerAlias, subqueryAlias, outerModel);
+        const filterSql = this.buildFilterConditions(filters, subqueryAlias, relationship);
+        return this.combineConditions(correlation, filterSql);
+    }
+    buildCorrelation(relationship, outerAlias, subqueryAlias, outerModel) {
+        const fkKey = this.getFkKey(relationship);
+        const outerPkKey = this.getOuterPrimaryKey(relationship, outerModel);
+        const relatedPkKey = this.getRelatedPrimaryKey(relationship);
+        if (relationship.relation === 'one-to-many') {
+            return `${subqueryAlias}."${fkKey}" = ${outerAlias}."${outerPkKey}"`;
+        }
+        const outerFk = relationship.columnName;
+        return `${outerAlias}."${outerFk}" = ${subqueryAlias}."${relatedPkKey}"`;
+    }
+    getOuterPrimaryKey(relationship, outerModel) {
+        if (!outerModel) {
+            return 'id';
+        }
+        const entity = this.entityStorage.get(outerModel);
+        if (!entity) {
+            return 'id';
+        }
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+    buildFilterConditions(filters, alias, relationship) {
+        if (!filters || Object.keys(filters).length === 0) {
+            return '';
+        }
+        const conditionBuilder = this.getConditionBuilder();
+        const entity = relationship.entity();
+        return conditionBuilder.build(filters, alias, entity);
+    }
+    combineConditions(correlation, filterSql) {
+        if (!filterSql) {
+            return correlation;
+        }
+        return `${correlation} AND ${filterSql}`;
+    }
+    resolveTableName(relationship) {
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            const name = relationship.entity().name.toLowerCase();
+            return `public.${name}`;
+        }
+        const schema = entity.schema || 'public';
+        const tableName = entity.tableName || relationship.entity().name.toLowerCase();
+        return `${schema}."${tableName}"`;
+    }
+    generateAlias() {
+        const alias = `sq${this.aliasCounter}`;
+        this.aliasCounter++;
+        return alias;
+    }
+    getFkKey(relationship) {
+        if (typeof relationship.fkKey === 'undefined') {
+            return 'id';
+        }
+        if (typeof relationship.fkKey === 'string') {
+            return relationship.fkKey;
+        }
+        const match = /\.(?<propriedade>[\w]+)/.exec(relationship.fkKey.toString());
+        const propertyKey = match ? match.groups.propriedade : '';
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            throw new Error(`Entity not found in storage for relationship. ` +
+                `Make sure the entity ${relationship.entity().name} is decorated with @Entity()`);
+        }
+        const property = Object.entries(entity.properties).find(([key, _value]) => key === propertyKey)?.[1];
+        if (property) {
+            return property.options.columnName;
+        }
+        const relation = entity.relations.find((rel) => rel.propertyKey === propertyKey);
+        if (relation && relation.columnName) {
+            return relation.columnName;
+        }
+        throw new Error(`Property or relation "${propertyKey}" not found in entity "${entity.tableName}". ` +
+            `Available properties: ${Object.keys(entity.properties).join(', ')}. ` +
+            `Available relations: ${entity.relations.map((r) => r.propertyKey).join(', ')}`);
+    }
+    getRelatedPrimaryKey(relationship) {
+        const entity = this.entityStorage.get(relationship.entity());
+        if (!entity) {
+            return 'id';
+        }
+        for (const prop in entity.properties) {
+            if (entity.properties[prop].options.isPrimary) {
+                return prop;
+            }
+        }
+        return 'id';
+    }
+}
+exports.SqlSubqueryBuilder = SqlSubqueryBuilder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cheetah.js/orm",
-  "version": "0.1.146",
+  "version": "0.1.149",
   "description": "A simple ORM for Cheetah.js.",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -55,5 +55,5 @@
     "bun",
     "value-object"
   ],
-  "gitHead": "01d694ffaf36a91a0367d2d79c3f87f43402f62a"
+  "gitHead": "a683593a24301375a1cb97b6523f35f6fafed85c"
 }