@synstack/query/dist/query.index.js

Query engine

// src/query.engine.ts
import { z as z2 } from "zod/v4";

// src/query.lib.ts
import { z } from "zod/v4";
function queryPredicate(name, params, handler) {
  return {
    name,
    schema: z.object({
      [name]: params
    }),
    handler
    // Todo: fix this
  };
}
var alwaysSchema = z.object({
  always: z.literal(true)
}).meta({ id: "always" });
var neverSchema = z.object({
  never: z.literal(true)
}).meta({ id: "never" });
function querySchema(extras) {
  const schema = z.union([
    z.object({
      get and() {
        return z.array(schema).min(2);
      }
    }),
    z.object({
      get or() {
        return z.array(schema).min(2);
      }
    }),
    z.object({
      get not() {
        return schema;
      }
    }),
    alwaysSchema,
    neverSchema,
    ...extras
    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
  ]);
  return schema;
}
function queryApply(predicates, query, input, options) {
  if (query === void 0) return false;
  const schema = querySchema(predicates.map((c) => c.schema));
  const parsedQuery = options?.skipQueryValidation ? query : schema.parse(query);
  function apply(query2, input2) {
    if ("always" in query2) {
      return true;
    }
    if ("never" in query2) {
      return false;
    }
    if ("and" in query2) {
      if (query2.and.length === 0) return false;
      return query2.and.every((q) => apply(q, input2));
    }
    if ("or" in query2) {
      if (query2.or.length === 0) return false;
      return query2.or.some((q) => apply(q, input2));
    }
    if ("not" in query2) {
      return !apply(query2.not, input2);
    }
    return predicates.some((c) => {
      if (c.name in query2) return c.handler(query2[c.name])(input2);
      return false;
    });
  }
  return apply(parsedQuery, input);
}

// src/query.engine.ts
var QueryEngine = class _QueryEngine {
  predicates;
  _schema;
  constructor(predicates) {
    this.predicates = predicates;
    this._schema = querySchema(
      this.predicates.map((p) => p.schema)
    );
  }
  static default() {
    return new _QueryEngine([]);
  }
  static addPredicate(name, params, handler) {
    return new _QueryEngine([
      queryPredicate(name, params, handler)
    ]);
  }
  addPredicate(name, params, handler) {
    return new _QueryEngine([
      ...this.predicates,
      queryPredicate(name, params, handler)
    ]);
  }
  get schema() {
    return this._schema;
  }
  get jsonSchema() {
    return z2.toJSONSchema(this.schema);
  }
  match(query, input, options) {
    return queryApply(this.predicates, query, input, options);
  }
};
export {
  QueryEngine
};
//# sourceMappingURL=query.index.js.map