@wxn0brp/vql-client 0.0.2 → 0.0.5

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export type VQLQuery = string | object;
+import { VQLR } from "./vql.js";
+export type VQLQuery = string | VQLR;
 export type VQLResult<T = any> = Promise<T>;
 export type VQLTransport = (query: VQLQuery) => VQLResult;
 export type VQLHooks = {
@@ -9,6 +10,7 @@ export type VQLHooks = {
 export declare function initVQLClient(config: {
     transport?: VQLTransport;
     hooks?: VQLHooks;
+    defaultFetchUrl?: string;
 }): void;
 export declare function fetchVQL<T = any>(query: VQLQuery): Promise<T>;
 export declare function resetVQLClient(): void;

package/dist/index.js

@@ -1,10 +1,13 @@
 let transport = defaultFetchTransport;
 let hooks = {};
+let defaultFetchUrl = "/VQL";
 export function initVQLClient(config) {
     if (config.transport)
         transport = config.transport;
     if (config.hooks)
         hooks = config.hooks;
+    if (config.defaultFetchUrl)
+        defaultFetchUrl = config.defaultFetchUrl;
 }
 export async function fetchVQL(query) {
     const start = Date.now();
@@ -30,7 +33,7 @@ export function resetVQLClient() {
     hooks = {};
 }
 export async function defaultFetchTransport(query) {
-    const res = await fetch("/VQL", {
+    const res = await fetch(defaultFetchUrl, {
         method: "POST",
         headers: {
             "Content-Type": "application/json"

package/dist/vql-client.cjs

@@ -27,9 +27,11 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var transport = defaultFetchTransport;
 var hooks = {};
+var defaultFetchUrl = "/VQL";
 function initVQLClient(config) {
   if (config.transport) transport = config.transport;
   if (config.hooks) hooks = config.hooks;
+  if (config.defaultFetchUrl) defaultFetchUrl = config.defaultFetchUrl;
 }
 async function fetchVQL(query) {
   var _a, _b, _c, _d, _e;
@@ -55,7 +57,7 @@ function resetVQLClient() {
   hooks = {};
 }
 async function defaultFetchTransport(query) {
-  const res = await fetch("/VQL", {
+  const res = await fetch(defaultFetchUrl, {
     method: "POST",
     headers: {
       "Content-Type": "application/json"

package/dist/vql-client.min.js

@@ -1 +1 @@
-var VQLClient=(()=>{var Q=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var T=Object.prototype.hasOwnProperty;var x=(t,r)=>{for(var a in r)Q(t,a,{get:r[a],enumerable:!0})},E=(t,r,a,i)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of l(r))!T.call(t,o)&&o!==a&&Q(t,o,{get:()=>r[o],enumerable:!(i=f(r,o))||i.enumerable});return t};var h=t=>E(Q({},"__esModule",{value:!0}),t);var m={};x(m,{defaultFetchTransport:()=>s,fetchVQL:()=>d,initVQLClient:()=>V,resetVQLClient:()=>c});var u=s,n={};function V(t){t.transport&&(u=t.transport),t.hooks&&(n=t.hooks)}async function d(t){var a,i,o,p,y;let r=Date.now();try{(a=n.onStart)==null||a.call(n,t);let e=await u(t),w=Date.now()-r;if((i=n.onEnd)==null||i.call(n,t,w,e),e!=null&&e.err){let L=new Error(e.err);throw(o=n.onError)==null||o.call(n,t,L),L}return(p=e==null?void 0:e.result)!=null?p:e}catch(e){throw(y=n.onError)==null||y.call(n,t,e),e}}function c(){u=s,n={}}async function s(t){let r=await fetch("/VQL",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({query:t})});if(!r.ok)throw new Error(`VQL request failed: ${r.status}`);return await r.json()}typeof window!="undefined"&&(window.VQLClient={fetchVQL:d,initVQLClient:V,resetVQLClient:c,defaultFetchTransport:s});return h(m);})();
+var VQLClient=(()=>{var Q=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var h=Object.prototype.hasOwnProperty;var x=(t,r)=>{for(var a in r)Q(t,a,{get:r[a],enumerable:!0})},m=(t,r,a,i)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of T(r))!h.call(t,o)&&o!==a&&Q(t,o,{get:()=>r[o],enumerable:!(i=w(r,o))||i.enumerable});return t};var E=t=>m(Q({},"__esModule",{value:!0}),t);var F={};x(F,{defaultFetchTransport:()=>s,fetchVQL:()=>d,initVQLClient:()=>l,resetVQLClient:()=>f});var u=s,e={},V="/VQL";function l(t){t.transport&&(u=t.transport),t.hooks&&(e=t.hooks),t.defaultFetchUrl&&(V=t.defaultFetchUrl)}async function d(t){var a,i,o,p,y;let r=Date.now();try{(a=e.onStart)==null||a.call(e,t);let n=await u(t),c=Date.now()-r;if((i=e.onEnd)==null||i.call(e,t,c,n),n!=null&&n.err){let L=new Error(n.err);throw(o=e.onError)==null||o.call(e,t,L),L}return(p=n==null?void 0:n.result)!=null?p:n}catch(n){throw(y=e.onError)==null||y.call(e,t,n),n}}function f(){u=s,e={}}async function s(t){let r=await fetch(V,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({query:t})});if(!r.ok)throw new Error(`VQL request failed: ${r.status}`);return await r.json()}typeof window!="undefined"&&(window.VQLClient={fetchVQL:d,initVQLClient:l,resetVQLClient:f,defaultFetchTransport:s});return E(F);})();

package/dist/vql.d.ts

@@ -0,0 +1,275 @@
+export interface Data {
+    [key: string]: any;
+}
+export interface Context {
+    [key: string]: any;
+}
+export type Id = string;
+export type LogicalOperators = {
+    $and?: Array<SearchOptions>;
+    $or?: Array<SearchOptions>;
+    $not?: SearchOptions;
+};
+export type ComparisonOperators = {
+    $gt?: Record<string, number>;
+    $lt?: Record<string, number>;
+    $gte?: Record<string, number>;
+    $lte?: Record<string, number>;
+    $in?: Record<string, any[]>;
+    $nin?: Record<string, any[]>;
+    $between?: Record<string, [
+        number,
+        number
+    ]>;
+};
+export type TypeAndExistenceOperators = {
+    $exists?: Record<string, boolean>;
+    $type?: Record<string, string>;
+};
+export type ArrayOperators = {
+    $arrinc?: Record<string, any[]>;
+    $arrincall?: Record<string, any[]>;
+    $size?: Record<string, number>;
+};
+export type StringOperators = {
+    $regex?: Record<string, RegExp>;
+    $startsWith?: Record<string, string>;
+    $endsWith?: Record<string, string>;
+};
+export type OtherOperators = {
+    $subset?: Record<string, any>;
+};
+export type PredefinedSearchOperators = LogicalOperators & ComparisonOperators & TypeAndExistenceOperators & ArrayOperators & StringOperators & OtherOperators;
+export type SearchOptions = PredefinedSearchOperators & Arg;
+export type ArrayUpdater = {
+    $push?: any;
+    $pushset?: any;
+    $pull?: any;
+    $pullall?: any;
+};
+export type ObjectUpdater = {
+    $merge?: any;
+};
+export type ValueUpdater = {
+    $set?: any;
+    $inc?: any;
+    $dec?: any;
+    $unset?: any;
+    $rename?: any;
+};
+export type UpdaterArg = ArrayUpdater & ObjectUpdater & ValueUpdater & {
+    [key: string]: any;
+};
+export interface Arg {
+    _id?: Id;
+    [key: string]: any;
+}
+export type SearchFunc<T = any> = (data: T, context: Context) => boolean;
+export type UpdaterFunc<T = any> = (data: T, context: Context) => boolean;
+export type Search<T = any> = SearchOptions | SearchFunc<T>;
+export type Updater<T = any> = UpdaterArg | UpdaterArg[] | UpdaterFunc<T>;
+export interface DbFindOpts {
+    reverse?: boolean;
+    max?: number;
+}
+export interface FindOpts {
+    select?: string[];
+    exclude?: string[];
+    transform?: Function;
+}
+export interface Transaction {
+    type: "update" | "updateOne" | "updateOneOrAdd" | "remove" | "removeOne";
+    search: Search;
+    updater?: Updater;
+    addArg?: Arg;
+    idGen?: boolean;
+    context?: Context;
+}
+export interface ValtheraCompatible {
+    c(collection: string): CollectionManager;
+    getCollections(): Promise<string[]>;
+    checkCollection(collection: string): Promise<boolean>;
+    issetCollection(collection: string): Promise<boolean>;
+    add<T = Data>(collection: string, data: Arg, id_gen?: boolean): Promise<T>;
+    find<T = Data>(collection: string, search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    findOne<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts): Promise<T | null>;
+    findStream<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts, limit?: number): Promise<AsyncGenerator<T>>;
+    update(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    updateOne(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    remove(collection: string, search: Search, context?: Context): Promise<boolean>;
+    removeOne(collection: string, search: Search, context?: Context): Promise<boolean>;
+    removeCollection(collection: string): Promise<boolean>;
+    transaction(collection: string, transaction: Transaction[]): Promise<boolean>;
+    updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+}
+declare class CollectionManager {
+    private db;
+    private collection;
+    constructor(db: ValtheraCompatible, collection: string);
+    add<T = Data>(data: Arg, id_gen?: boolean): Promise<T>;
+    find<T = Data>(search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    findOne<T = Data>(search: Search, context?: Context, findOpts?: FindOpts): Promise<T>;
+    findStream<T = Data>(search: Search, context?: Context, findOpts?: FindOpts, limit?: number): AsyncGenerator<T>;
+    update(search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    updateOne(search: Search, updater: Updater, context?: Context): Promise<boolean>;
+    remove(search: Search, context?: Context): Promise<boolean>;
+    removeOne(search: Search, context?: Context): Promise<boolean>;
+    updateOneOrAdd(search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+}
+declare namespace RelationTypes {
+    type Path = [
+        string,
+        string
+    ];
+    type FieldPath = string[];
+    interface DBS {
+        [key: string]: ValtheraCompatible;
+    }
+    interface Relation {
+        [key: string]: RelationConfig;
+    }
+    interface RelationConfig {
+        path: Path;
+        pk?: string;
+        fk?: string;
+        as?: string;
+        select?: string[];
+        findOpts?: DbFindOpts;
+        type?: "1" | "11" | "1n" | "nm";
+        relations?: Relation;
+        through?: {
+            table: string;
+            db?: string;
+            pk: string;
+            fk: string;
+        };
+    }
+}
+export type VQLQuery = {
+    find: VQLFind;
+    findOne: VQLFindOne;
+    f: VQLFindOne;
+    add: VQLAdd;
+    update: VQLUpdate;
+    updateOne: VQLUpdateOne;
+    remove: VQLRemove;
+    removeOne: VQLRemoveOne;
+    updateOneOrAdd: VQLUpdateOneOrAdd;
+    removeCollection: VQLCollectionOperation;
+    checkCollection: VQLCollectionOperation;
+    issetCollection: VQLCollectionOperation;
+    getCollections: {};
+};
+export type VQLQueryData = {
+    find: VQLFind;
+} | {
+    findOne: VQLFindOne;
+} | {
+    f: VQLFindOne;
+} | {
+    add: VQLAdd;
+} | {
+    update: VQLUpdate;
+} | {
+    updateOne: VQLUpdateOne;
+} | {
+    remove: VQLRemove;
+} | {
+    removeOne: VQLRemoveOne;
+} | {
+    updateOneOrAdd: VQLUpdateOneOrAdd;
+} | {
+    removeCollection: VQLCollectionOperation;
+} | {
+    checkCollection: VQLCollectionOperation;
+} | {
+    issetCollection: VQLCollectionOperation;
+} | {
+    getCollections: {};
+};
+export interface VQLRequest {
+    db: string;
+    d: VQLQueryData;
+}
+export interface VQLFind {
+    collection: string;
+    search?: Search;
+    limit?: number;
+    fields?: VQLFields;
+    select?: VQLFields;
+    relations?: VQLRelations;
+    options?: DbFindOpts;
+    searchOpts?: FindOpts;
+}
+export interface VQLFindOne {
+    collection: string;
+    search: Search;
+    fields?: VQLFields;
+    select?: VQLFields;
+    relations?: VQLRelations;
+    searchOpts?: FindOpts;
+}
+export interface VQLAdd {
+    collection: string;
+    data: Arg;
+    id_gen?: boolean;
+}
+export interface VQLUpdate {
+    collection: string;
+    search: Search;
+    updater: UpdaterArg;
+}
+export interface VQLUpdateOne {
+    collection: string;
+    search: Search;
+    updater: UpdaterArg;
+}
+export interface VQLRemove {
+    collection: string;
+    search: Search;
+}
+export interface VQLRemoveOne {
+    collection: string;
+    search: Search;
+}
+export interface VQLUpdateOneOrAdd {
+    collection: string;
+    search: Search;
+    updater: UpdaterArg;
+    add_arg?: Arg;
+    id_gen?: boolean;
+}
+export interface VQLCollectionOperation {
+    collection: string;
+}
+export type VQLFields = Record<string, boolean | number> | string[];
+export type VQLRelations = Record<string, VQLFind | VQLFindOne>;
+export interface RelationQuery {
+    r: {
+        path: RelationTypes.Path;
+        search: Search;
+        relations: RelationTypes.Relation;
+        many?: boolean;
+        options?: DbFindOpts;
+        select?: RelationTypes.FieldPath[];
+    };
+}
+export interface VQLRef {
+    ref?: string;
+    var?: {
+        [k: string]: any;
+    };
+}
+export type VQLRefRequired = VQLRef & Required<Pick<VQLRef, "ref">>;
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export type VQL = (VQLRequest | RelationQuery) & VQLRef;
+export type VQLR = VQL | (DeepPartial<VQL> & VQLRefRequired) | VQLRefRequired;
+export interface VQLError {
+    err: true;
+    msg: string;
+    c: number;
+    why?: string;
+}
+export {};

package/dist/vql.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql-client",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -20,6 +20,12 @@
       "import": "./dist/index.js",
       "require": "./dist/index.cjs",
       "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "require": "./dist/*.cjs",
+      "default": "./dist/*.js"
     }
   }
 }