@wxn0brp/vql-client 0.1.0 → 0.2.1

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { VqlQueryRaw } from "./vql";
+import { VQLUQ } from "./vql";
 export type VQLResult<T = any> = Promise<T>;
-export type VQLTransport = (query: VqlQueryRaw) => VQLResult;
+export type VQLTransport = (query: VQLUQ) => VQLResult;
 export interface VQLHooks {
-    onStart?: (query: VqlQueryRaw, hookContext: any) => void;
-    onEnd?: (query: VqlQueryRaw, durationMs: number, result: any, hookContext: any) => void;
-    onError?: (query: VqlQueryRaw, error: unknown, result?: any, hookContext?: any) => void;
+    onStart?: (query: VQLUQ, hookContext: any) => void;
+    onEnd?: (query: VQLUQ, durationMs: number, result: any, hookContext: any) => void;
+    onError?: (query: VQLUQ, error: unknown, result?: any, hookContext?: any) => void;
 }
 export interface Config {
     transport?: VQLTransport;
@@ -12,5 +12,5 @@ export interface Config {
     url?: string;
 }
 export declare const VConfig: Config;
-export declare function fetchVQL<T = any>(query: VqlQueryRaw<T>, hookContext?: any): Promise<T>;
-export declare function defTransport(query: VqlQueryRaw): Promise<any>;
+export declare function fetchVQL<T = any>(query: VQLUQ<T>, vars?: any, hookContext?: any): Promise<T>;
+export declare function defTransport(query: VQLUQ): Promise<any>;

package/dist/index.js

@@ -4,11 +4,18 @@ export const VConfig = {
     hooks: {},
     url: "/VQL"
 };
-export async function fetchVQL(query, hookContext = {}) {
+export async function fetchVQL(query, vars = {}, hookContext = {}) {
     const { transport, hooks } = VConfig;
     const start = Date.now();
     try {
+        hookContext = Object.assign({}, vars, hookContext);
         hooks.onStart?.(query, hookContext);
+        if (typeof query === "string" && Object.keys(vars).length) {
+            query = {
+                query: query,
+                var: vars
+            };
+        }
         const res = await transport(query);
         const duration = Date.now() - start;
         hooks.onEnd?.(query, duration, res, hookContext);

package/dist/min.js

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

package/dist/vql.d.ts

@@ -85,13 +85,13 @@ declare class CollectionManager<D = Data> {
     private collection;
     constructor(db: ValtheraCompatible, collection: string);
     add<T = Data>(data: Arg<T & D>, id_gen?: boolean): Promise<T>;
-    find<T = Data>(search?: Search<T & D>, context?: VContext, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>): Promise<T[]>;
-    findOne<T = Data>(search?: Search<T & Data>, context?: VContext, findOpts?: FindOpts<T & Data>): Promise<T>;
+    find<T = Data>(search?: Search<T & D>, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T[]>;
+    findOne<T = Data>(search?: Search<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T>;
     update<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, context?: VContext): Promise<boolean>;
     updateOne<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, context?: VContext): Promise<boolean>;
     remove<T = Data>(search: Search<T & Data>, context?: VContext): Promise<boolean>;
     removeOne<T = Data>(search: Search<T & Data>, context?: VContext): Promise<boolean>;
-    updateOneOrAdd<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, add_arg?: Arg<T & Data>, context?: VContext, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, { add_arg, context, id_gen }: UpdateOneOrAdd<T & Data>): Promise<boolean>;
 }
 export interface ValtheraCompatible {
     c(collection: string): CollectionManager;
@@ -99,14 +99,19 @@ export interface ValtheraCompatible {
     ensureCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
     add<T = Data>(collection: string, data: Arg<T>, id_gen?: boolean): Promise<T>;
-    find<T = Data>(collection: string, search: Search<T>, context?: VContext, options?: DbFindOpts<T>, findOpts?: FindOpts<T>): Promise<T[]>;
-    findOne<T = Data>(collection: string, search: Search<T>, context?: VContext, findOpts?: FindOpts<T>): Promise<T | null>;
+    find<T = Data>(collection: string, search?: Search<T>, options?: DbFindOpts<T>, findOpts?: FindOpts<T>, context?: VContext): Promise<T[]>;
+    findOne<T = Data>(collection: string, search?: Search<T>, findOpts?: FindOpts<T>, context?: VContext): Promise<T | null>;
     update<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
     updateOne<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
     remove<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
     removeOne<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
     removeCollection(collection: string): Promise<boolean>;
-    updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, add_arg?: Arg<T>, context?: VContext, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, opts?: UpdateOneOrAdd<T>): Promise<boolean>;
+}
+export interface UpdateOneOrAdd<T> {
+    add_arg?: Arg<T>;
+    id_gen?: boolean;
+    context?: VContext;
 }
 declare namespace RelationTypes {
     type Path = [
@@ -137,134 +142,100 @@ declare namespace RelationTypes {
         };
     }
 }
-export interface VQLQuery<T = any> {
-    find: VQLFind<T>;
-    findOne: VQLFindOne<T>;
-    f: VQLFindOne<T>;
-    add: VQLAdd<T>;
-    update: VQLUpdate<T>;
-    updateOne: VQLUpdateOne<T>;
-    remove: VQLRemove<T>;
-    removeOne: VQLRemoveOne<T>;
-    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
-    removeCollection: VQLCollectionOperation;
-    ensureCollection: VQLCollectionOperation;
-    issetCollection: VQLCollectionOperation;
-    getCollections: {};
-}
-export type VQLQueryData<T = any> = {
-    find: VQLFind<T>;
-} | {
-    findOne: VQLFindOne<T>;
-} | {
-    f: VQLFindOne<T>;
-} | {
-    add: VQLAdd<T>;
-} | {
-    update: VQLUpdate<T>;
-} | {
-    updateOne: VQLUpdateOne<T>;
-} | {
-    remove: VQLRemove<T>;
-} | {
-    removeOne: VQLRemoveOne<T>;
-} | {
-    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
-} | {
-    removeCollection: VQLCollectionOperation;
-} | {
-    ensureCollection: VQLCollectionOperation;
-} | {
-    issetCollection: VQLCollectionOperation;
-} | {
-    getCollections: {};
-};
-export interface VQLRequest<T = any> {
-    db: string;
-    d: VQLQueryData<T>;
-}
-export interface VQLFind<T = any> {
+export interface VQL_OP_Find<T = any> {
     collection: string;
     search?: Search<T>;
     limit?: number;
-    fields?: VQLFields;
-    select?: VQLFields;
-    relations?: VQLRelations;
+    fields?: VQL_Fields;
+    select?: VQL_Fields;
     options?: DbFindOpts<T>;
     searchOpts?: FindOpts<T>;
 }
-export interface VQLFindOne<T = any> {
+export interface VQL_OP_FindOne<T = any> {
     collection: string;
     search: Search<T>;
-    fields?: VQLFields;
-    select?: VQLFields;
-    relations?: VQLRelations;
+    fields?: VQL_Fields;
+    select?: VQL_Fields;
     searchOpts?: FindOpts<T>;
 }
-export interface VQLAdd<T = any> {
+export interface VQL_OP_Add<T = any> {
     collection: string;
     data: Arg<T>;
     id_gen?: boolean;
 }
-export interface VQLUpdate<T = any> {
+export interface VQL_OP_Update<T = any> {
     collection: string;
     search: Search<T>;
     updater: UpdaterArg<T>;
 }
-export interface VQLUpdateOne<T = any> {
+export interface VQL_OP_Remove<T = any> {
     collection: string;
     search: Search<T>;
-    updater: UpdaterArg<T>;
 }
-export interface VQLRemove<T = any> {
-    collection: string;
-    search: Search<T>;
-}
-export interface VQLRemoveOne<T = any> {
-    collection: string;
-    search: Search<T>;
-}
-export interface VQLUpdateOneOrAdd<T = any> {
+export interface VQL_OP_UpdateOneOrAdd<T = any> {
     collection: string;
     search: Search<T>;
     updater: UpdaterArg<T>;
     add_arg?: Arg<T>;
     id_gen?: boolean;
 }
-export interface VQLCollectionOperation {
+export interface VQL_OP_CollectionOperation {
     collection: string;
 }
-export type VQLFields = Record<string, boolean | number> | string[];
-export type VQLRelations = Record<string, VQLFind | VQLFindOne>;
-export interface RelationQuery {
+export type VQL_Fields = Record<string, boolean | number> | string[];
+export type VQL_Query_CRUD_Data<T = any> = {
+    find: VQL_OP_Find<T>;
+} | {
+    findOne: VQL_OP_FindOne<T>;
+} | {
+    f: VQL_OP_FindOne<T>;
+} | {
+    add: VQL_OP_Add<T>;
+} | {
+    update: VQL_OP_Update<T>;
+} | {
+    updateOne: VQL_OP_Update<T>;
+} | {
+    remove: VQL_OP_Remove<T>;
+} | {
+    removeOne: VQL_OP_Remove<T>;
+} | {
+    updateOneOrAdd: VQL_OP_UpdateOneOrAdd<T>;
+} | {
+    removeCollection: VQL_OP_CollectionOperation;
+} | {
+    ensureCollection: VQL_OP_CollectionOperation;
+} | {
+    issetCollection: VQL_OP_CollectionOperation;
+} | {
+    getCollections: {};
+};
+export interface VQL_Query_CRUD<T = any> {
+    db: string;
+    d: VQL_Query_CRUD_Data<T>;
+}
+export interface VQL_Query_Relation {
     r: {
         path: RelationTypes.Path;
         search: Search;
         relations: RelationTypes.Relation;
         many?: boolean;
         options?: DbFindOpts;
-        select?: RelationTypes.FieldPath[];
+        select?: RelationTypes.FieldPath[] | Record<string, any>;
     };
 }
-export interface VQLRef {
-    ref?: string;
+export interface VQL_Var {
     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<T = any> = (VQLRequest<T> | RelationQuery) & VQLRef;
-export type VQLR<T = any> = VQL<T> | (DeepPartial<VQL<T>> & VQLRefRequired) | VQLRefRequired;
+export type VQL_Query<T = any> = (VQL_Query_CRUD<T> | VQL_Query_Relation) & VQL_Var;
+export type VQLUQ<T = any> = VQL_Query<T> | string | {
+    query: string;
+} & VQL_Var;
 export interface VQLError {
     err: true;
     msg: string;
     c: number;
-    why?: string;
 }
-export type VqlQueryRaw<T = any> = VQLR<T> | string | {
-    query: string;
-} & VQLRef;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql-client",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "VQL Client",