Implement a list of operations <, >, =, <> for the size property

Author: FSou1

README.md

@@ -63,17 +63,25 @@ export interface IDirEntry {
 }
 ```
 
-## Example queries
+## Queries
+
+### Supported 
 
 `select * from .`
 
 `select * from root`
 
 `select * from root/sub-a`
 
-## TODO
+`select * from root where size > 1000000`
+
+`select * from root where size < 1000000`
+
+`select * from root where size = 1000000`
+
+`select * from root where size <> 1000000`
 
-`select * from root where size > 0`
+### TODO
 
 `select * from root where isDirectory = true`
 

deps.ts

@@ -5,4 +5,6 @@ export {
 export {
   assert,
   assertExists,
+  assertEquals,
+  assertThrows
 } from "https://deno.land/std@0.82.0/testing/asserts.ts";

mod_test.ts

@@ -4,7 +4,7 @@ import { fsselect } from "./mod.ts";
 
 Deno.test("if 'select * from .' works", async () => {
   const result = await fsselect("select * from .");
-  assert(result.length === 16);
+  assert(result.length === 18);
 });
 
 Deno.test("if 'select * from root' works", async () => {
@@ -14,5 +14,11 @@ Deno.test("if 'select * from root' works", async () => {
 
 Deno.test("if 'select * from root/test_folder_with_file' works", async () => {
   const result = await fsselect("select * from root/test_folder_with_file");
-  assert(result.length === 1);
+  assert(result.length === 2);
 });
+
+Deno.test("if 'select * from root/test_folder_with_file where size > 1000000' works", async () => {
+  const result = await fsselect("select * from root/test_folder_with_file where size > 1000000");
+  assert(result.length === 1);
+  assert(result[0].name === 'b-file-1MB.txt');
+});

root/test_folder_with_file/b-file-1MB.txt

@@ -1,4 +1,5 @@
 import { IDirEntry, IQuery } from "./types.ts";
+import { where } from "./where.ts";
 
 export async function select(query: IQuery): Promise<IDirEntry[]> {
   const output: IDirEntry[] = [];
@@ -11,13 +12,17 @@ export async function select(query: IQuery): Promise<IDirEntry[]> {
         isDirectory: entry.isDirectory,
         isSymlink: entry.isSymlink,
       };
+
       const path = `${query.from}/${entry.name}`;
       const info = await Deno.lstat(path);
       row.size = info.size;
       row.accessedAt = info.atime;
       row.createdAt = info.birthtime;
       row.modifiedAt = info.mtime;
-      output.push(row);
+
+      if (where(row, query.where)) {
+        output.push(row);
+      }
     }
   } catch (err) {
   }

select.ts

@@ -11,6 +11,7 @@ Deno.test("if an empty array is returned when the folder is missing", async () =
     type: "select",
     fields: ["*"],
     from: "missing-folder",
+    where: null,
   };
 
   const result = await select(query);
@@ -23,6 +24,7 @@ Deno.test("if an empty array is returned when the path is a file", async () => {
     type: "select",
     fields: ["*"],
     from: "select_test.ts",
+    where: null,
   };
 
   const result = await select(query);
@@ -35,11 +37,12 @@ Deno.test("if an existing file entry is returned when the path is a correct fold
     type: "select",
     fields: ["*"],
     from: "root/test_folder_with_file",
+    where: null,
   };
 
   const result = await select(query);
 
-  assert(result.length === 1);
+  assert(result.length === 2);
   assertEquals(result[0].name, "a-file.txt");
   assertEquals(result[0].size, 12);
   assertEquals(result[0].isFile, true);
@@ -55,6 +58,7 @@ Deno.test("if an existing directory entry is returned when the path is a correct
     type: "select",
     fields: ["*"],
     from: "root/test_folder_with_folder",
+    where: null,
   };
 
   const result = await select(query);
@@ -68,3 +72,31 @@ Deno.test("if an existing directory entry is returned when the path is a correct
   assert(result[0].createdAt);
   assert(result[0].modifiedAt);
 });
+
+Deno.test("if a 1MB file is returned when the where clause is correct", async () => {
+  const query: IQuery = {
+    type: "select",
+    fields: ["*"],
+    from: "root/test_folder_with_file",
+    where: {
+      conditions: [
+        {
+          left: "size",
+          op: "GreaterThan",
+          right: 1000000,
+        },
+      ],
+    },
+  };
+
+  const result = await select(query);
+
+  assert(result.length === 1);
+  assertEquals(result[0].name, "b-file-1MB.txt");
+  assertEquals(result[0].isFile, true);
+  assertEquals(result[0].isDirectory, false);
+  assertEquals(result[0].isSymlink, false);
+  assert(result[0].accessedAt);
+  assert(result[0].createdAt);
+  assert(result[0].modifiedAt);
+});

select_test.ts

@@ -2,6 +2,7 @@ export interface IQuery {
   type: string;
   fields: string[];
   from: string;
+  where: IWhereClause | null;
 }
 
 export interface IDirEntry {
@@ -14,3 +15,13 @@ export interface IDirEntry {
   isDirectory?: boolean;
   isSymlink?: boolean;
 }
+
+export interface IWhereClause {
+  conditions: IWhereCondition[];
+}
+
+export interface IWhereCondition {
+  left: string;
+  op: 'Different' | 'GreaterThan' | 'LessThan' | 'Equal' | 'Like';
+  right: string | number;
+}

types.ts

@@ -0,0 +1,60 @@
+import { IDirEntry, IWhereClause, IWhereCondition } from "./types.ts";
+
+export function where(entry: IDirEntry, where: IWhereClause | null): boolean {
+  const conditions = where?.conditions;
+  if (!conditions?.length) {
+    return true;
+  }
+
+  for (const condition of conditions) {
+    if (!meet(entry, condition)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function meet(entry: IDirEntry, condition: IWhereCondition): boolean {
+  const { left, op, right } = condition;
+
+  if (left === "size") {
+    const operations = {
+      "GreaterThan": greaterThan,
+      "LessThan": lessThan,
+      "Equal": equal,
+      "Different": different,
+      "Like": null,
+    };
+
+    const operation = operations[op];
+    if (!operation) {
+      throw new Error(
+        `The operation '${op}' is not supported for the '${left}' property`,
+      );
+    }
+
+    return operation(entry.size, right);
+  }
+
+  return false;
+}
+
+function greaterThan(
+  left: number | undefined,
+  right: number | string,
+): boolean {
+  return typeof left !== "undefined" && left > right;
+}
+
+function lessThan(left: number | undefined, right: number | string): boolean {
+  return typeof left !== "undefined" && left < right;
+}
+
+function equal(left: number | undefined, right: number | string): boolean {
+  return typeof left !== "undefined" && left === right;
+}
+
+function different(left: number | undefined, right: number | string): boolean {
+  return typeof left !== "undefined" && left !== right;
+}