132 lines
3.4 KiB
TypeScript
132 lines
3.4 KiB
TypeScript
import type { LuaExpression } from "$common/space_lua/ast.ts";
|
|
import {
|
|
LuaEnv,
|
|
luaGet,
|
|
luaKeys,
|
|
type LuaStackFrame,
|
|
} from "$common/space_lua/runtime.ts";
|
|
import { evalExpression } from "$common/space_lua/eval.ts";
|
|
import { asyncQuickSort } from "$common/space_lua/util.ts";
|
|
|
|
function buildItemEnv(item: any, env: LuaEnv, sf: LuaStackFrame): LuaEnv {
|
|
const itemEnv = new LuaEnv(env);
|
|
for (const key of luaKeys(item)) {
|
|
itemEnv.setLocal(key, luaGet(item, key, sf));
|
|
}
|
|
return itemEnv;
|
|
}
|
|
|
|
export type LuaOrderBy = {
|
|
expr: LuaExpression;
|
|
desc: boolean;
|
|
};
|
|
|
|
export type LuaSelect = {
|
|
name: string;
|
|
expr?: LuaExpression;
|
|
};
|
|
|
|
/**
|
|
* Represents a query for a collection
|
|
*/
|
|
export type LuaCollectionQuery = {
|
|
// The filter expression evaluated with Lua
|
|
where?: LuaExpression;
|
|
// The order by expression evaluated with Lua
|
|
orderBy?: LuaOrderBy[];
|
|
// The select expression evaluated with Lua
|
|
select?: LuaSelect[];
|
|
// The limit of the query
|
|
limit?: number;
|
|
// The offset of the query
|
|
offset?: number;
|
|
};
|
|
|
|
export interface LuaQueryCollection {
|
|
query(
|
|
query: LuaCollectionQuery,
|
|
env: LuaEnv,
|
|
sf: LuaStackFrame,
|
|
): Promise<any[]>;
|
|
}
|
|
|
|
/**
|
|
* Implements a query collection for a regular JavaScript array
|
|
*/
|
|
export class ArrayQueryCollection<T> implements LuaQueryCollection {
|
|
constructor(private readonly array: T[]) {}
|
|
|
|
async query(
|
|
query: LuaCollectionQuery,
|
|
env: LuaEnv,
|
|
sf: LuaStackFrame,
|
|
): Promise<any[]> {
|
|
let result: any[] = [];
|
|
|
|
// Filter the array
|
|
for (const item of this.array) {
|
|
const itemEnv = buildItemEnv(item, env, sf);
|
|
if (query.where && !await evalExpression(query.where, itemEnv, sf)) {
|
|
continue;
|
|
}
|
|
result.push(item);
|
|
}
|
|
|
|
// Apply the select
|
|
if (query.select) {
|
|
const newResult = [];
|
|
for (const item of result) {
|
|
const itemEnv = buildItemEnv(item, env, sf);
|
|
const newItem: Record<string, any> = {};
|
|
for (const select of query.select) {
|
|
if (select.expr) {
|
|
newItem[select.name] = await evalExpression(
|
|
select.expr,
|
|
itemEnv,
|
|
sf,
|
|
);
|
|
} else {
|
|
newItem[select.name] = item[select.name];
|
|
}
|
|
}
|
|
newResult.push(newItem);
|
|
}
|
|
result = newResult;
|
|
}
|
|
|
|
// Apply the order by
|
|
if (query.orderBy) {
|
|
result = await asyncQuickSort(result, async (a, b) => {
|
|
// Compare each orderBy clause until we find a difference
|
|
for (const { expr, desc } of query.orderBy!) {
|
|
const aEnv = buildItemEnv(a, env, sf);
|
|
const bEnv = buildItemEnv(b, env, sf);
|
|
|
|
const aVal = await evalExpression(expr, aEnv, sf);
|
|
const bVal = await evalExpression(expr, bEnv, sf);
|
|
|
|
if (aVal < bVal) {
|
|
return desc ? 1 : -1;
|
|
}
|
|
if (aVal > bVal) {
|
|
return desc ? -1 : 1;
|
|
}
|
|
// If equal, continue to next orderBy clause
|
|
}
|
|
return 0; // All orderBy clauses were equal
|
|
});
|
|
}
|
|
|
|
// Apply the limit and offset
|
|
if (query.limit !== undefined && query.offset !== undefined) {
|
|
result = result.slice(query.offset, query.offset + query.limit);
|
|
} else if (query.limit !== undefined) {
|
|
result = result.slice(0, query.limit);
|
|
} else if (query.offset !== undefined) {
|
|
result = result.slice(query.offset);
|
|
}
|
|
|
|
return Promise.resolve(result);
|
|
}
|
|
}
|