@wxn0brp/vql-client 0.0.3 → 0.0.6

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-export type VQLQuery = string | object;
+import { VQLR, VQLRef } from "./vql.js";
+export type VQLQuery = VQLR | string | {
+    query: string;
+} & VQLRef;
 export type VQLResult<T = any> = Promise<T>;
 export type VQLTransport = (query: VQLQuery) => VQLResult;
 export type VQLHooks = {

package/dist/vql-client.min.js

@@ -1 +1 @@
-var VQLClient=(()=>{var u=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var T=Object.getOwnPropertyNames;var h=Object.prototype.hasOwnProperty;var x=(t,r)=>{for(var a in r)u(t,a,{get:r[a],enumerable:!0})},E=(t,r,a,s)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of T(r))!h.call(t,o)&&o!==a&&u(t,o,{get:()=>r[o],enumerable:!(s=w(r,o))||s.enumerable});return t};var m=t=>E(u({},"__esModule",{value:!0}),t);var F={};x(F,{defaultFetchTransport:()=>i,fetchVQL:()=>d,initVQLClient:()=>V,resetVQLClient:()=>c});var Q=i,e={},L="/VQL";function V(t){t.transport&&(Q=t.transport),t.hooks&&(e=t.hooks),t.defaultFetchUrl&&(L=t.defaultFetchUrl)}async function d(t){var a,s,o,p,y;let r=Date.now();try{(a=e.onStart)==null||a.call(e,t);let n=await Q(t),f=Date.now()-r;if((s=e.onEnd)==null||s.call(e,t,f,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 c(){Q=i,e={}}async function i(t){let r=await fetch(L,{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:i});return m(F);})();
+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 R={};x(R,{defaultFetchTransport:()=>s,fetchVQL:()=>d,initVQLClient:()=>l,resetVQLClient:()=>f});var u=s,e={},y="/VQL";function l(t){t.transport&&(u=t.transport),t.hooks&&(e=t.hooks),t.defaultFetchUrl&&(y=t.defaultFetchUrl)}async function d(t){var a,i,o,p,L;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 V=new Error(n.err);throw(o=e.onError)==null||o.call(e,t,V),V}return(p=n==null?void 0:n.result)!=null?p:n}catch(n){throw(L=e.onError)==null||L.call(e,t,n),n}}function f(){u=s,e={}}async function s(t){let r=await fetch(y,{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(R);})();

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.3",
+  "version": "0.0.6",
   "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"
     }
   }
 }