@cubicweb/client - npm Package Compare versions

Comparing version 2.1.1 to 3.0.0-alpha.4

lib/schema/classes/EntitySchema.d.ts

@@ -36,20 +36,20 @@ import { EntityRawSchemaArray } from "../raw/Entities";
     /**
-     * Gets the list of relation definitions schemas with this entity as subject.
-     * In case a relation definition schema has this entity as both object and subject,
-     * there will be dupicates when used along with `objectRelationsDefinitions`.
+     * Gets the list of attribute schemas (relation definition schemas with final at false)
+     * for this entity schema.
      */
-    get subjectRelationDefinitions(): RelationDefinitionSchema<E, R, MatchedRelationDefinition<E, R, {
+    get attributes(): RelationDefinitionSchema<E, R, MatchedRelationDefinition<E, R, {
         subject: ERawSchema["type"];
-        final: false;
+        final: true;
     }>>[];
+    get relationDefinitions(): {
+        subject: RelationDefinitionSchema<E, R, MatchedRelationDefinition<E, R, {
+            subject: ERawSchema["type"];
+            final: false;
+        }>>[];
+        object: RelationDefinitionSchema<E, R, MatchedRelationDefinition<E, R, {
+            object: ERawSchema["type"];
+            final: false;
+        }>>[];
+    };
     /**
-     * Gets the list of relation definitions schemas with this entity as object.
-     * In case a relation definition schema has this entity as both object and subject,
-     * there will be dupicates when used along with `subjectRelationDefinitions`.
-     */
-    get objectRelationsDefinitions(): RelationDefinitionSchema<E, R, MatchedRelationDefinition<E, R, {
-        object: ERawSchema["type"];
-        final: false;
-    }>>[];
-    /**
      * Finds relations in the Schema matching the partial relation given.
@@ -63,11 +63,3 @@ *
     }>>[];
-    /**
-     * Gets the list of attribute schemas (relation definition schemas with final at false)
-     * for this entity schema.
-     */
-    get attributes(): RelationDefinitionSchema<E, R, MatchedRelationDefinition<E, R, {
-        subject: ERawSchema["type"];
-        final: true;
-    }>>[];
 }
 //# sourceMappingURL=EntitySchema.d.ts.map

lib/schema/classes/EntitySchema.js

@@ -41,22 +41,22 @@ "use strict";
     /**
-     * Gets the list of relation definitions schemas with this entity as subject.
-     * In case a relation definition schema has this entity as both object and subject,
-     * there will be dupicates when used along with `objectRelationsDefinitions`.
+     * Gets the list of attribute schemas (relation definition schemas with final at false)
+     * for this entity schema.
      */
-    get subjectRelationDefinitions() {
+    get attributes() {
         return this.schema.matchRelationDefinitions({
+            final: true,
             subject: this.type,
-            final: false,
         });
     }
-    /**
-     * Gets the list of relation definitions schemas with this entity as object.
-     * In case a relation definition schema has this entity as both object and subject,
-     * there will be dupicates when used along with `subjectRelationDefinitions`.
-     */
-    get objectRelationsDefinitions() {
-        return this.schema.matchRelationDefinitions({
-            object: this.type,
-            final: false,
-        });
+    get relationDefinitions() {
+        return {
+            subject: this.schema.matchRelationDefinitions({
+                subject: this.type,
+                final: false,
+            }),
+            object: this.schema.matchRelationDefinitions({
+                object: this.type,
+                final: false,
+            }),
+        };
     }
@@ -72,14 +72,4 @@ /**
     }
-    /**
-     * Gets the list of attribute schemas (relation definition schemas with final at false)
-     * for this entity schema.
-     */
-    get attributes() {
-        return this.schema.matchRelationDefinitions({
-            final: true,
-            subject: this.type,
-        });
-    }
 }
 exports.EntitySchema = EntitySchema;
 //# sourceMappingURL=EntitySchema.js.map

lib/schema/classes/RelationDefinitionSchema.d.ts

@@ -6,2 +6,3 @@ import { EntityRawSchemaArray } from "../raw/Entities";
 import { Schema } from "./Schema";
+import { EntityRole } from "./Utils";
 /**
@@ -59,12 +60,7 @@ * Wrapper around raw relation definition schemas from the Schema.
      */
-    get cardinality(): RDef["cardinality"];
+    get cardinality(): {
+        subject: Cardinality;
+        object: Cardinality;
+    };
     /**
-     * The cardinality of this relation definition schema's subject.
-     */
-    get subjectCardinality(): Cardinality;
-    /**
-     * The cardinality of this relation definition schema's object.
-     */
-    get objectCardinality(): Cardinality;
-    /**
      * Gets the entity associated to this relation definition schema's subject.
@@ -87,4 +83,4 @@ *
      */
-    isRequired(role: "subject" | "object"): boolean;
+    isRequired(role: EntityRole): boolean;
 }
 //# sourceMappingURL=RelationDefinitionSchema.d.ts.map

lib/schema/classes/RelationDefinitionSchema.js

@@ -70,17 +70,8 @@ "use strict";
     get cardinality() {
-        return this.relDef.cardinality;
+        return {
+            subject: this.relDef.cardinality[0],
+            object: this.relDef.cardinality[1],
+        };
     }
     /**
-     * The cardinality of this relation definition schema's subject.
-     */
-    get subjectCardinality() {
-        return this.relDef.cardinality[0];
-    }
-    /**
-     * The cardinality of this relation definition schema's object.
-     */
-    get objectCardinality() {
-        return this.relDef.cardinality[1];
-    }
-    /**
      * Gets the entity associated to this relation definition schema's subject.
@@ -118,10 +109,3 @@ *
     isRequired(role) {
-        let cardinality;
-        if (role === "subject") {
-            cardinality = this.subjectCardinality;
-        }
-        else {
-            cardinality = this.objectCardinality;
-        }
-        return (0, Utils_1.cardinalityRequired)(cardinality);
+        return (0, Utils_1.isCardinalityRequired)(this.cardinality[role]);
     }
@@ -128,0 +112,0 @@ }

lib/schema/classes/Utils.d.ts

@@ -6,2 +6,6 @@ import { EntityRawSchemaArray } from "../raw/Entities";
 /**
+ * An entity role in a relation.
+ */
+export type EntityRole = "subject" | "object";
+/**
  * Returns the given schema using loose typing.
@@ -20,4 +24,106 @@ * Can be useful when working with generic schemas
  */
-export declare function cardinalityRequired(cardinality: Cardinality): boolean;
+export declare function isCardinalityRequired(cardinality: Cardinality): boolean;
 /**
+ * Checks if the cardinality allows multiple entities to be present
+ *
+ * @param cardinality The cardinility to check
+ * @returns True if the cardinality is `*` or `+`
+ */
+export declare const isCardinalityMultiple: (cardinality: Cardinality) => boolean;
+/**
+ * Checks if the cardinality allows entities to be absent
+ *
+ * @param cardinality The cardinility to check
+ * @returns True if the cardinality is `?` or `*`
+ */
+export declare const isCardinalityOptional: (cardinality: Cardinality) => boolean;
+/**
+ * Reverses the given role name
+ *
+ * @param role The role to reverse
+ * @returns "object" if the given role was "subject", "subject" otherwise
+ */
+export declare function getOppositeRelationRole(role: EntityRole): EntityRole;
+/**
+ * Checks if the given relation type is reversed.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to check
+ * @returns True if the relation type starts with the reverse indicator
+ */
+export declare const isRelationTypeReversed: (relationType: string) => boolean;
+/**
+ * Gets the entity role in the given relation type by
+ * checking for the reverse indicator
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to check
+ * @returns "subject" if the relation is not reversed, "object" otherwise
+ */
+export declare const getRoleFromRelationType: (relationType: string) => EntityRole;
+/**
+ * Adds the reverse indicator from the relation type if it is not already present.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @returns The relation type with the reverse indicator added or removed
+ */
+export declare const getReverseRelationType: (relationType: string) => string;
+/**
+ * Clears the reverse indicator from the relation type if it is present.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @returns The relation type with the reverse indicator added or removed
+ */
+export declare const getRawRelationType: (relationType: string) => string;
+/**
+ * Returns the relation type with the reverse indicator added if necessary.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @param role The entity role in the relation
+ * @returns A relation type with the reverse indicator if necessary
+ */
+export declare const getRelationType: (relationType: string, role: EntityRole) => string;
+/**
+ * Finds the relation matching the provided source, relation typ and target
+ *
+ * @param entitySchema The entity schema the relation is from
+ * @param sourceType The entity type acting as source for the relation
+ * @param relationType The type of the relation to use. Can have the reverse indicator to decide the role of the source/target entities
+ * @param targetType The entity type acting as target for the relation
+ * @returns The relation definition matching the triplet source relation target
+ */
+export declare const getRelationDefinition: (entitySchema: EntitySchema, sourceType: string, relationType: string, targetType: string) => import("./RelationDefinitionSchema").RelationDefinitionSchema<EntityRawSchemaArray, RelationDefinitionRawSchemaArray<EntityRawSchemaArray>, Readonly<{
+    type: string;
+    description: string;
+    cardinality: "**" | "*1" | "*?" | "*+" | "1*" | "11" | "1?" | "1+" | "?*" | "?1" | "??" | "?+" | "+*" | "+1" | "+?" | "++";
+    subject: string;
+} & ((import("../raw/RelationDefinitions").BuildObj & {
+    final: true;
+    constraints: import("../..").AttributeConstraint[];
+    options: import("../raw/RelationDefinitions").AttributeOptions;
+}) | {
+    object: string;
+    final: false;
+    constraints: import("../..").RelationConstraint[];
+    options: import("../raw/RelationDefinitions").RelationOptions;
+})>> | undefined;
+/**
  * Partial raw relation definition schema type.
@@ -24,0 +130,0 @@ */

lib/schema/classes/Utils.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAttributeRichString = exports.hasAttributeWithName = exports.cardinalityRequired = exports.getLooseSchema = void 0;
+exports.isAttributeRichString = exports.hasAttributeWithName = exports.getRelationDefinition = exports.getRelationType = exports.getRawRelationType = exports.getReverseRelationType = exports.getRoleFromRelationType = exports.isRelationTypeReversed = exports.getOppositeRelationRole = exports.isCardinalityOptional = exports.isCardinalityMultiple = exports.isCardinalityRequired = exports.getLooseSchema = void 0;
+// This prefix is often applied to relation types as convention
+// indicating a relation is viewed from the object's point of view
+// We do not export it and instead encourage users to use the utility functions
+const REVERSE_INDICATOR = "reverse_";
 /**
@@ -21,6 +25,142 @@ * Returns the given schema using loose typing.
  */
-function cardinalityRequired(cardinality) {
+function isCardinalityRequired(cardinality) {
     return cardinality === "1" || cardinality === "+";
 }
-exports.cardinalityRequired = cardinalityRequired;
+exports.isCardinalityRequired = isCardinalityRequired;
+/**
+ * Checks if the cardinality allows multiple entities to be present
+ *
+ * @param cardinality The cardinility to check
+ * @returns True if the cardinality is `*` or `+`
+ */
+const isCardinalityMultiple = (cardinality) => {
+    return cardinality === "*" || cardinality === "+";
+};
+exports.isCardinalityMultiple = isCardinalityMultiple;
+/**
+ * Checks if the cardinality allows entities to be absent
+ *
+ * @param cardinality The cardinility to check
+ * @returns True if the cardinality is `?` or `*`
+ */
+const isCardinalityOptional = (cardinality) => {
+    return cardinality === "?" || cardinality === "*";
+};
+exports.isCardinalityOptional = isCardinalityOptional;
+/**
+ * Reverses the given role name
+ *
+ * @param role The role to reverse
+ * @returns "object" if the given role was "subject", "subject" otherwise
+ */
+function getOppositeRelationRole(role) {
+    return role === "subject" ? "object" : "subject";
+}
+exports.getOppositeRelationRole = getOppositeRelationRole;
+/**
+ * Checks if the given relation type is reversed.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to check
+ * @returns True if the relation type starts with the reverse indicator
+ */
+const isRelationTypeReversed = (relationType) => {
+    return relationType.startsWith(REVERSE_INDICATOR);
+};
+exports.isRelationTypeReversed = isRelationTypeReversed;
+/**
+ * Gets the entity role in the given relation type by
+ * checking for the reverse indicator
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to check
+ * @returns "subject" if the relation is not reversed, "object" otherwise
+ */
+const getRoleFromRelationType = (relationType) => {
+    return (0, exports.isRelationTypeReversed)(relationType) ? "object" : "subject";
+};
+exports.getRoleFromRelationType = getRoleFromRelationType;
+/**
+ * Adds the reverse indicator from the relation type if it is not already present.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @returns The relation type with the reverse indicator added or removed
+ */
+const getReverseRelationType = (relationType) => {
+    if (!(0, exports.isRelationTypeReversed)(relationType)) {
+        return `${REVERSE_INDICATOR}${relationType}`;
+    }
+    else {
+        return relationType;
+    }
+};
+exports.getReverseRelationType = getReverseRelationType;
+/**
+ * Clears the reverse indicator from the relation type if it is present.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @returns The relation type with the reverse indicator added or removed
+ */
+const getRawRelationType = (relationType) => {
+    if ((0, exports.isRelationTypeReversed)(relationType)) {
+        return relationType.replace(REVERSE_INDICATOR, "");
+    }
+    else {
+        return relationType;
+    }
+};
+exports.getRawRelationType = getRawRelationType;
+/**
+ * Returns the relation type with the reverse indicator added if necessary.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @param role The entity role in the relation
+ * @returns A relation type with the reverse indicator if necessary
+ */
+const getRelationType = (relationType, role) => {
+    return role === "subject"
+        ? relationType
+        : (0, exports.getReverseRelationType)(relationType);
+};
+exports.getRelationType = getRelationType;
+/**
+ * Finds the relation matching the provided source, relation typ and target
+ *
+ * @param entitySchema The entity schema the relation is from
+ * @param sourceType The entity type acting as source for the relation
+ * @param relationType The type of the relation to use. Can have the reverse indicator to decide the role of the source/target entities
+ * @param targetType The entity type acting as target for the relation
+ * @returns The relation definition matching the triplet source relation target
+ */
+const getRelationDefinition = (entitySchema, sourceType, relationType, targetType) => {
+    const role = (0, exports.getRoleFromRelationType)(relationType);
+    const match = entitySchema.matchRelationDefinitions({
+        [role]: sourceType,
+        type: (0, exports.getRawRelationType)(relationType),
+        [getOppositeRelationRole(role)]: targetType,
+    });
+    if (match.length > 0) {
+        return match[0];
+    }
+    return undefined;
+};
+exports.getRelationDefinition = getRelationDefinition;
 function hasAttributeWithName(entitySchema, attributeNameSearched) {
@@ -27,0 +167,0 @@ for (const entityAttribute of entitySchema.attributes) {

lib/schema/raw/RelationDefinitions.d.ts

@@ -0,1 +1,2 @@
+import { EntityRole } from "../classes/Utils";
 import { AttributeConstraint, RelationConstraint } from "./Constraints";
@@ -88,4 +89,4 @@ import { EntityRawSchema, EntityRawSchemaArray } from "./Entities";
     inlined?: boolean;
-    fulltext_container?: "subject" | "object";
-    composite?: "subject" | "object";
+    fulltext_container?: EntityRole;
+    composite?: EntityRole;
 };
@@ -92,0 +93,0 @@ /**

package.json

@@ -5,3 +5,3 @@ {
   "author": "Logilab",
-  "version": "2.1.1",
+  "version": "3.0.0-alpha.4",
   "license": "LGPL-3.0-or-later",
@@ -8,0 +8,0 @@ "main": "lib/index.js",

src/schema/classes/EntitySchema.ts

@@ -52,7 +52,6 @@ import { EntityRawSchemaArray } from "../raw/Entities";
   /**
-   * Gets the list of relation definitions schemas with this entity as subject.
-   * In case a relation definition schema has this entity as both object and subject,
-   * there will be dupicates when used along with `objectRelationsDefinitions`.
+   * Gets the list of attribute schemas (relation definition schemas with final at false)
+   * for this entity schema.
    */
-  get subjectRelationDefinitions(): RelationDefinitionSchema<
+  get attributes(): RelationDefinitionSchema<
     E,
@@ -63,29 +62,41 @@ R,
       R,
-      { subject: ERawSchema["type"]; final: false }
+      { subject: ERawSchema["type"]; final: true }
     >
   >[] {
     return this.schema.matchRelationDefinitions({
+      final: true,
       subject: this.type,
-      final: false,
     });
   }
 
-  /**
-   * Gets the list of relation definitions schemas with this entity as object.
-   * In case a relation definition schema has this entity as both object and subject,
-   * there will be dupicates when used along with `subjectRelationDefinitions`.
-   */
-  get objectRelationsDefinitions(): RelationDefinitionSchema<
-    E,
-    R,
-    MatchedRelationDefinition<
+  get relationDefinitions(): {
+    subject: RelationDefinitionSchema<
       E,
       R,
-      { object: ERawSchema["type"]; final: false }
-    >
-  >[] {
-    return this.schema.matchRelationDefinitions({
-      object: this.type,
-      final: false,
-    });
+      MatchedRelationDefinition<
+        E,
+        R,
+        { subject: ERawSchema["type"]; final: false }
+      >
+    >[];
+    object: RelationDefinitionSchema<
+      E,
+      R,
+      MatchedRelationDefinition<
+        E,
+        R,
+        { object: ERawSchema["type"]; final: false }
+      >
+    >[];
+  } {
+    return {
+      subject: this.schema.matchRelationDefinitions({
+        subject: this.type,
+        final: false,
+      }),
+      object: this.schema.matchRelationDefinitions({
+        object: this.type,
+        final: false,
+      }),
+    };
   }
@@ -108,21 +119,2 @@
   }
-
-  /**
-   * Gets the list of attribute schemas (relation definition schemas with final at false)
-   * for this entity schema.
-   */
-  get attributes(): RelationDefinitionSchema<
-    E,
-    R,
-    MatchedRelationDefinition<
-      E,
-      R,
-      { subject: ERawSchema["type"]; final: true }
-    >
-  >[] {
-    return this.schema.matchRelationDefinitions({
-      final: true,
-      subject: this.type,
-    });
-  }
 }

src/schema/classes/RelationDefinitionSchema.ts

@@ -10,3 +10,3 @@ import { InconsistentSchemaError } from "../../Errors";
 import { Schema } from "./Schema";
-import { cardinalityRequired } from "./Utils";
+import { EntityRole, isCardinalityRequired } from "./Utils";
 
@@ -88,21 +88,10 @@ /**
    */
-  get cardinality(): RDef["cardinality"] {
-    return this.relDef.cardinality;
+  get cardinality(): { subject: Cardinality; object: Cardinality } {
+    return {
+      subject: this.relDef.cardinality[0] as Cardinality,
+      object: this.relDef.cardinality[1] as Cardinality,
+    };
   }
 
   /**
-   * The cardinality of this relation definition schema's subject.
-   */
-  get subjectCardinality(): Cardinality {
-    return this.relDef.cardinality[0] as Cardinality;
-  }
-
-  /**
-   * The cardinality of this relation definition schema's object.
-   */
-  get objectCardinality(): Cardinality {
-    return this.relDef.cardinality[1] as Cardinality;
-  }
-
-  /**
    * Gets the entity associated to this relation definition schema's subject.
@@ -149,11 +138,5 @@ *
    */
-  isRequired(role: "subject" | "object") {
-    let cardinality: Cardinality;
-    if (role === "subject") {
-      cardinality = this.subjectCardinality;
-    } else {
-      cardinality = this.objectCardinality;
-    }
-    return cardinalityRequired(cardinality);
+  isRequired(role: EntityRole) {
+    return isCardinalityRequired(this.cardinality[role]);
   }
 }

src/schema/classes/Utils.ts

@@ -10,3 +10,13 @@ import { EntityRawSchemaArray } from "../raw/Entities";
 
+// This prefix is often applied to relation types as convention
+// indicating a relation is viewed from the object's point of view
+// We do not export it and instead encourage users to use the utility functions
+const REVERSE_INDICATOR = "reverse_";
+
 /**
+ * An entity role in a relation.
+ */
+export type EntityRole = "subject" | "object";
+
+/**
  * Returns the given schema using loose typing.
@@ -33,3 +43,3 @@ * Can be useful when working with generic schemas
  */
-export function cardinalityRequired(cardinality: Cardinality): boolean {
+export function isCardinalityRequired(cardinality: Cardinality): boolean {
   return cardinality === "1" || cardinality === "+";
@@ -39,2 +49,141 @@ }
 /**
+ * Checks if the cardinality allows multiple entities to be present
+ *
+ * @param cardinality The cardinility to check
+ * @returns True if the cardinality is `*` or `+`
+ */
+export const isCardinalityMultiple = (cardinality: Cardinality): boolean => {
+  return cardinality === "*" || cardinality === "+";
+};
+
+/**
+ * Checks if the cardinality allows entities to be absent
+ *
+ * @param cardinality The cardinility to check
+ * @returns True if the cardinality is `?` or `*`
+ */
+export const isCardinalityOptional = (cardinality: Cardinality): boolean => {
+  return cardinality === "?" || cardinality === "*";
+};
+
+/**
+ * Reverses the given role name
+ *
+ * @param role The role to reverse
+ * @returns "object" if the given role was "subject", "subject" otherwise
+ */
+export function getOppositeRelationRole(role: EntityRole): EntityRole {
+  return role === "subject" ? "object" : "subject";
+}
+
+/**
+ * Checks if the given relation type is reversed.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to check
+ * @returns True if the relation type starts with the reverse indicator
+ */
+export const isRelationTypeReversed = (relationType: string): boolean => {
+  return relationType.startsWith(REVERSE_INDICATOR);
+};
+
+/**
+ * Gets the entity role in the given relation type by
+ * checking for the reverse indicator
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to check
+ * @returns "subject" if the relation is not reversed, "object" otherwise
+ */
+export const getRoleFromRelationType = (relationType: string): EntityRole => {
+  return isRelationTypeReversed(relationType) ? "object" : "subject";
+};
+
+/**
+ * Adds the reverse indicator from the relation type if it is not already present.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @returns The relation type with the reverse indicator added or removed
+ */
+export const getReverseRelationType = (relationType: string): string => {
+  if (!isRelationTypeReversed(relationType)) {
+    return `${REVERSE_INDICATOR}${relationType}`;
+  } else {
+    return relationType;
+  }
+};
+
+/**
+ * Clears the reverse indicator from the relation type if it is present.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @returns The relation type with the reverse indicator added or removed
+ */
+export const getRawRelationType = (relationType: string): string => {
+  if (isRelationTypeReversed(relationType)) {
+    return relationType.replace(REVERSE_INDICATOR, "");
+  } else {
+    return relationType;
+  }
+};
+
+/**
+ * Returns the relation type with the reverse indicator added if necessary.
+ *
+ * A reversed relation means the relation is considered from the object entity
+ * point of view.
+ * The reverse indicator is a prefix added as a convention in CubicWeb.
+ *
+ * @param relationType The relation type to transform
+ * @param role The entity role in the relation
+ * @returns A relation type with the reverse indicator if necessary
+ */
+export const getRelationType = (relationType: string, role: EntityRole) => {
+  return role === "subject"
+    ? relationType
+    : getReverseRelationType(relationType);
+};
+
+/**
+ * Finds the relation matching the provided source, relation typ and target
+ *
+ * @param entitySchema The entity schema the relation is from
+ * @param sourceType The entity type acting as source for the relation
+ * @param relationType The type of the relation to use. Can have the reverse indicator to decide the role of the source/target entities
+ * @param targetType The entity type acting as target for the relation
+ * @returns The relation definition matching the triplet source relation target
+ */
+export const getRelationDefinition = (
+  entitySchema: EntitySchema,
+  sourceType: string,
+  relationType: string,
+  targetType: string
+) => {
+  const role = getRoleFromRelationType(relationType);
+  const match = entitySchema.matchRelationDefinitions({
+    [role]: sourceType,
+    type: getRawRelationType(relationType),
+    [getOppositeRelationRole(role)]: targetType,
+  });
+  if (match.length > 0) {
+    return match[0];
+  }
+  return undefined;
+};
+
+/**
  * Partial raw relation definition schema type.
@@ -41,0 +190,0 @@ */

src/schema/raw/RelationDefinitions.ts

@@ -0,1 +1,2 @@
+import { EntityRole } from "../classes/Utils";
 import { AttributeConstraint, RelationConstraint } from "./Constraints";
@@ -125,4 +126,4 @@ import { EntityRawSchema, EntityRawSchemaArray } from "./Entities";
   inlined?: boolean;
-  fulltext_container?: "subject" | "object";
-  composite?: "subject" | "object";
+  fulltext_container?: EntityRole;
+  composite?: EntityRole;
 };
@@ -129,0 +130,0 @@

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

149665

increased by11.32%

Lines of code

3041

increased by12.09%

Worsened metrics

Number of low quality alerts

2

increased by100%

No dependency changes