Merge branch 'main' into cm/add-flows-homepage

Cargo.toml

@@ -12,6 +12,7 @@ members = [
     "libs/@local/hash-authorization",
     "libs/@local/hash-graph-types/rust",
     "libs/@local/hash-validation",
+    "libs/@local/repo-chores/rust",
     "libs/@local/temporal-client",
     "libs/@local/temporal-versioning",
     "tests/hash-graph-integration",

apps/hash-api/src/graph/ensure-system-graph-is-initialized/migrate-ontology-types/util/upgrade-entities.ts

@@ -61,9 +61,19 @@ export const upgradeWebEntities = async ({
         all: [
           {
             any: entityTypeBaseUrls.map((baseUrl) => ({
-              equal: [
-                { path: ["type(inheritanceDepth = 0)", "baseUrl"] },
-                { parameter: baseUrl },
+              all: [
+                {
+                  equal: [
+                    { path: ["type(inheritanceDepth = 0)", "baseUrl"] },
+                    { parameter: baseUrl },
+                  ],
+                },
+                {
+                  less: [
+                    { path: ["type(inheritanceDepth = 0)", "version"] },
+                    { parameter: migrationState.entityTypeVersions[baseUrl] },
+                  ],
+                },
               ],
             })),
           },

apps/hash-graph/libs/api/src/rest/mod.rs

@@ -658,6 +658,54 @@ impl Modify for FilterSchemaAddon {
                                 )
                                 .required("notEqual"),
                         )
+                        .item(
+                            ObjectBuilder::new()
+                                .title(Some("GreaterFilter"))
+                                .property(
+                                    "greater",
+                                    ArrayBuilder::new()
+                                        .items(Ref::from_schema_name("FilterExpression"))
+                                        .min_items(Some(2))
+                                        .max_items(Some(2)),
+                                )
+                                .required("notEqual"),
+                        )
+                        .item(
+                            ObjectBuilder::new()
+                                .title(Some("GreaterOrEqualFilter"))
+                                .property(
+                                    "greaterOrEqual",
+                                    ArrayBuilder::new()
+                                        .items(Ref::from_schema_name("FilterExpression"))
+                                        .min_items(Some(2))
+                                        .max_items(Some(2)),
+                                )
+                                .required("notEqual"),
+                        )
+                        .item(
+                            ObjectBuilder::new()
+                                .title(Some("LessFilter"))
+                                .property(
+                                    "less",
+                                    ArrayBuilder::new()
+                                        .items(Ref::from_schema_name("FilterExpression"))
+                                        .min_items(Some(2))
+                                        .max_items(Some(2)),
+                                )
+                                .required("notEqual"),
+                        )
+                        .item(
+                            ObjectBuilder::new()
+                                .title(Some("LessOrEqualFilter"))
+                                .property(
+                                    "lessOrEqual",
+                                    ArrayBuilder::new()
+                                        .items(Ref::from_schema_name("FilterExpression"))
+                                        .min_items(Some(2))
+                                        .max_items(Some(2)),
+                                )
+                                .required("notEqual"),
+                        )
                         .item(
                             ObjectBuilder::new()
                                 .title(Some("CosineDistanceFilter"))

apps/hash-graph/libs/graph/src/store/postgres/query/compile.rs

@@ -418,6 +418,22 @@ impl<'p, 'q: 'p, R: PostgresRecord> SelectCompiler<'p, 'q, R> {
                 rhs.as_ref()
                     .map(|expression| self.compile_filter_expression(expression).0),
             ),
+            Filter::Greater(lhs, rhs) => Condition::Greater(
+                self.compile_filter_expression(lhs).0,
+                self.compile_filter_expression(rhs).0,
+            ),
+            Filter::GreaterOrEqual(lhs, rhs) => Condition::GreaterOrEqual(
+                self.compile_filter_expression(lhs).0,
+                self.compile_filter_expression(rhs).0,
+            ),
+            Filter::Less(lhs, rhs) => Condition::Less(
+                self.compile_filter_expression(lhs).0,
+                self.compile_filter_expression(rhs).0,
+            ),
+            Filter::LessOrEqual(lhs, rhs) => Condition::LessOrEqual(
+                self.compile_filter_expression(lhs).0,
+                self.compile_filter_expression(rhs).0,
+            ),
             Filter::CosineDistance(lhs, rhs, max) => match (lhs, rhs) {
                 (FilterExpression::Path(path), FilterExpression::Parameter(parameter))
                 | (FilterExpression::Parameter(parameter), FilterExpression::Path(path)) => {

apps/hash-graph/libs/graph/src/store/query/filter.rs

@@ -45,6 +45,10 @@ pub enum Filter<'p, R: QueryRecord + ?Sized> {
         Option<FilterExpression<'p, R>>,
         Option<FilterExpression<'p, R>>,
     ),
+    Greater(FilterExpression<'p, R>, FilterExpression<'p, R>),
+    GreaterOrEqual(FilterExpression<'p, R>, FilterExpression<'p, R>),
+    Less(FilterExpression<'p, R>, FilterExpression<'p, R>),
+    LessOrEqual(FilterExpression<'p, R>, FilterExpression<'p, R>),
     CosineDistance(
         FilterExpression<'p, R>,
         FilterExpression<'p, R>,
@@ -169,6 +173,16 @@ where
                 ) => parameter.convert_to_parameter_type(path.expected_type())?,
                 (..) => {}
             },
+            Self::Greater(lhs, rhs)
+            | Self::GreaterOrEqual(lhs, rhs)
+            | Self::Less(lhs, rhs)
+            | Self::LessOrEqual(lhs, rhs) => match (lhs, rhs) {
+                (FilterExpression::Parameter(parameter), FilterExpression::Path(path))
+                | (FilterExpression::Path(path), FilterExpression::Parameter(parameter)) => {
+                    parameter.convert_to_parameter_type(path.expected_type())?;
+                }
+                (..) => {}
+            },
             Self::CosineDistance(lhs, rhs, max) => {
                 if let FilterExpression::Parameter(parameter) = max {
                     parameter.convert_to_parameter_type(ParameterType::F64)?;

libs/@local/repo-chores/scripts/shared/monorepo.ts → libs/@local/repo-chores/node/scripts/shared/monorepo.ts

@@ -6,7 +6,7 @@ import execa from "execa";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-export const monorepoRootDirPath = path.resolve(__dirname, "../../../../..");
+export const monorepoRootDirPath = path.resolve(__dirname, "../../../../../..");
 
 type YarnWorkspaceInfo = {
   location: string;

libs/@local/repo-chores/rust/Cargo.toml

@@ -0,0 +1,8 @@
+cargo-features = ["edition2024"]
+
+[package]
+name = "repo-chores"
+authors.workspace = true
+edition.workspace = true
+version = "0.0.0"
+publish = false