@webiny/handler-graphql 5.23.1 → 5.25.0-beta.0

package/builtInTypes/AnyScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["AnyScalar.ts"],"names":["returnValue","value","Any","GraphQLScalarType","name","description","serialize","parseValue"],"mappings":";;;;;;;AAAA;;AAEA,MAAMA,WAAW,GAAIC,KAAD,IAAqB;AACrC,SAAOA,KAAP;AACH,CAFD;;AAIO,MAAMC,GAAG,GAAG,IAAIC,0BAAJ,CAAsB;AACrCC,EAAAA,IAAI,EAAE,KAD+B;AAErCC,EAAAA,WAAW,EAAG,mDAFuB;AAGrCC,EAAAA,SAAS,EAAEN,WAH0B;AAIrCO,EAAAA,UAAU,EAAEP;AAJyB,CAAtB,CAAZ","sourcesContent":["import { GraphQLScalarType } from \"graphql\";\n\nconst returnValue = (value: any): any => {\n    return value;\n};\n\nexport const Any = new GraphQLScalarType({\n    name: \"Any\",\n    description: `A scalar type that represents an ambiguous value.`,\n    serialize: returnValue,\n    parseValue: returnValue\n});\n"]}

package/builtInTypes/DateScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["DateScalar.ts"],"names":["DateScalar","GraphQLScalarType","DateResolver","serialize","value","date","Date","toISOString","substr","ex"],"mappings":";;;;;;;;;;;AAAA;;AACA;;;;;;AACO,MAAMA,UAAU,GAAG,IAAIC,0BAAJ,iCACnBC,4BADmB;AAEtBC,EAAAA,SAAS,EAAEC,KAAK,IAAI;AAChB,QAAI,CAACA,KAAL,EAAY;AACR,aAAO,IAAP;AACH;;AACD,QAAI;AACA,YAAMC,IAAI,GAAG,IAAIC,IAAJ,CAASF,KAAT,CAAb;AACA,aAAOC,IAAI,CAACE,WAAL,GAAmBC,MAAnB,CAA0B,CAA1B,EAA6B,EAA7B,CAAP;AACH,KAHD,CAGE,OAAOC,EAAP,EAAW;AACT,UAAIL,KAAK,CAACG,WAAV,EAAuB;AACnB,eAAOH,KAAK,CAACG,WAAN,GAAoBC,MAApB,CAA2B,CAA3B,EAA8B,EAA9B,CAAP;AACH;;AACD,YAAMC,EAAN;AACH;AACJ;AAfqB,GAAnB","sourcesContent":["import { DateResolver } from \"graphql-scalars\";\nimport { GraphQLScalarType } from \"graphql\";\nexport const DateScalar = new GraphQLScalarType({\n    ...DateResolver,\n    serialize: value => {\n        if (!value) {\n            return null;\n        }\n        try {\n            const date = new Date(value);\n            return date.toISOString().substr(0, 10);\n        } catch (ex) {\n            if (value.toISOString) {\n                return value.toISOString().substr(0, 10);\n            }\n            throw ex;\n        }\n    }\n});\n"]}

package/builtInTypes/DateTimeScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["DateTimeScalar.ts"],"names":["DateTimeScalar","GraphQLScalarType","DateTimeResolver","serialize","value","date","Date","toISOString","ex"],"mappings":";;;;;;;;;;;AAAA;;AACA;;;;;;AACO,MAAMA,cAAc,GAAG,IAAIC,0BAAJ,iCACvBC,gCADuB;AAE1BC,EAAAA,SAAS,EAAEC,KAAK,IAAI;AAChB,QAAI,CAACA,KAAL,EAAY;AACR,aAAO,IAAP;AACH;;AACD,QAAI;AACA,YAAMC,IAAI,GAAG,IAAIC,IAAJ,CAASF,KAAT,CAAb;AACA,aAAOC,IAAI,CAACE,WAAL,EAAP;AACH,KAHD,CAGE,OAAOC,EAAP,EAAW;AACT,UAAIJ,KAAK,CAACG,WAAV,EAAuB;AACnB,eAAOH,KAAK,CAACG,WAAN,EAAP;AACH;;AACD,YAAMC,EAAN;AACH;AACJ;AAfyB,GAAvB","sourcesContent":["import { DateTimeResolver } from \"graphql-scalars\";\nimport { GraphQLScalarType } from \"graphql\";\nexport const DateTimeScalar = new GraphQLScalarType({\n    ...DateTimeResolver,\n    serialize: value => {\n        if (!value) {\n            return null;\n        }\n        try {\n            const date = new Date(value);\n            return date.toISOString();\n        } catch (ex) {\n            if (value.toISOString) {\n                return value.toISOString();\n            }\n            throw ex;\n        }\n    }\n});\n"]}

package/builtInTypes/DateTimeZScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["DateTimeZScalar.ts"],"names":["validateTimeZone","value","timeWithTimezone","split","WebinyError","separator","includes","zone","hoursMinutes","hours","minutes","undefined","length","DateTimeZScalar","GraphQLScalarType","name","description","parseValue","DateTimeResolver","serialize"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AAEA,MAAMA,gBAAgB,GAAIC,KAAD,IAAyB;AAC9C,QAAMC,gBAAgB,GAAGD,KAAK,CAACE,KAAN,CAAY,GAAZ,EAAiB,CAAjB,CAAzB;;AACA,MAAI,CAACD,gBAAL,EAAuB;AACnB,UAAM,IAAIE,cAAJ,CACF,kDADE,EAEF,0BAFE,EAGF;AACIH,MAAAA;AADJ,KAHE,CAAN;AAOH;;AACD,QAAMI,SAAS,GAAGH,gBAAgB,CAACI,QAAjB,CAA0B,GAA1B,IAAiC,GAAjC,GAAuC,GAAzD;AACA,QAAMC,IAAI,GAAGL,gBAAgB,CAACC,KAAjB,CAAuBE,SAAvB,EAAkC,CAAlC,CAAb;;AACA,MAAI,CAACE,IAAL,EAAW;AACP,UAAM,IAAIH,cAAJ,CACF,wCADE,EAEF,0BAFE,EAGF;AACIH,MAAAA,KAAK,EAAEC;AADX,KAHE,CAAN;AAOH;;AACD,QAAMM,YAAY,GAAGD,IAAI,CAACJ,KAAL,CAAW,GAAX,CAArB;AACA,QAAM,CAACM,KAAD,EAAQC,OAAR,IAAmBF,YAAzB;;AACA,MAAIC,KAAK,KAAKE,SAAV,IAAuBD,OAAO,KAAKC,SAAnC,IAAgDH,YAAY,CAACI,MAAb,KAAwB,CAA5E,EAA+E;AAC3E,UAAM,IAAIR,cAAJ,CACF,gDADE,EAEF,0BAFE,EAGF;AACIH,MAAAA,KAAK,EAAEM;AADX,KAHE,CAAN;AAOH;AACJ,CAjCD;AAkCA;AACA;AACA;AACA;;;AACO,MAAMM,eAAe,GAAG,IAAIC,0BAAJ,CAAsB;AACjDC,EAAAA,IAAI,EAAE,WAD2C;AAEjDC,EAAAA,WAAW,EAAE,+CAFoC;AAGjDC,EAAAA,UAAU,EAAEhB,KAAK,IAAI;AACjB;AACAiB,qCAAiBD,UAAjB,CAA4BhB,KAA5B;;AACAD,IAAAA,gBAAgB,CAACC,KAAD,CAAhB;AACA,WAAOA,KAAP;AACH,GARgD;AASjDkB,EAAAA,SAAS,EAAElB,KAAK,IAAI;AAChB,WAAOA,KAAP;AACH;AAXgD,CAAtB,CAAxB","sourcesContent":["import { DateTimeResolver } from \"graphql-scalars\";\nimport { GraphQLScalarType } from \"graphql\";\nimport WebinyError from \"@webiny/error\";\n\nconst validateTimeZone = (value: string): void => {\n    const timeWithTimezone = value.split(\"T\")[1];\n    if (!timeWithTimezone) {\n        throw new WebinyError(\n            \"Could not extract time with timezone from value.\",\n            \"DATE_TIME_TIMEZONE_ERROR\",\n            {\n                value\n            }\n        );\n    }\n    const separator = timeWithTimezone.includes(\"-\") ? \"-\" : \"+\";\n    const zone = timeWithTimezone.split(separator)[1];\n    if (!zone) {\n        throw new WebinyError(\n            \"Could not extract timezone from value.\",\n            \"DATE_TIME_TIMEZONE_ERROR\",\n            {\n                value: timeWithTimezone\n            }\n        );\n    }\n    const hoursMinutes = zone.split(\":\");\n    const [hours, minutes] = hoursMinutes;\n    if (hours === undefined || minutes === undefined || hoursMinutes.length !== 2) {\n        throw new WebinyError(\n            \"Could not extract hours or minutes from value.\",\n            \"DATE_TIME_TIMEZONE_ERROR\",\n            {\n                value: zone\n            }\n        );\n    }\n};\n/**\n * A custom type for dateTime with the timezone.\n * Must be in format \"YYYY-MM-ddTHH:mm:ss+HH:mm\".\n */\nexport const DateTimeZScalar = new GraphQLScalarType({\n    name: \"DateTimeZ\",\n    description: \"A custom type for dateTime with the timezone.\",\n    parseValue: value => {\n        // this serves as validator\n        DateTimeResolver.parseValue(value);\n        validateTimeZone(value);\n        return value;\n    },\n    serialize: value => {\n        return value;\n    }\n});\n"]}

package/builtInTypes/JsonScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["JsonScalar.ts"],"names":["JsonScalar","JSONResolver"],"mappings":";;;;;;;AAAA;;AACO,MAAMA,UAAU,GAAGC,4BAAnB","sourcesContent":["import { JSONResolver } from \"graphql-scalars\";\nexport const JsonScalar = JSONResolver;\n"]}

package/builtInTypes/LongScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["LongScalar.ts"],"names":["LongScalar","LongResolver"],"mappings":";;;;;;;AAAA;;AACO,MAAMA,UAAU,GAAGC,4BAAnB","sourcesContent":["import { LongResolver } from \"graphql-scalars\";\nexport const LongScalar = LongResolver;\n"]}

package/builtInTypes/NumberScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["NumberScalar.ts"],"names":["parseValue","value","String","match","WebinyError","undefined","isNaN","parseFloat","Number","GraphQLScalarType","name","description","serialize","ex","console","log","message","code","data","parseLiteral","ast","kind","Kind","INT","FLOAT","Error"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AAEA,MAAMA,UAAU,GAAIC,KAAD,IAAgB;AAC/B,MAAIC,MAAM,CAACD,KAAD,CAAN,CAAcE,KAAd,CAAoB,KAApB,MAA+B,IAAnC,EAAyC;AACrC,UAAM,IAAIC,cAAJ,CAAgB,sCAAhB,EAAwD,eAAxD,EAAyE;AAC3EH,MAAAA;AAD2E,KAAzE,CAAN;AAGH,GAJD,MAIO,IAAI,OAAOA,KAAP,KAAiB,QAArB,EAA+B;AAClC,WAAOA,KAAP;AACH,GAFM,MAEA,IAAIA,KAAK,KAAK,IAAV,IAAkBA,KAAK,KAAKI,SAAhC,EAA2C;AAC9C,WAAO,IAAP;AACH,GAFM,MAEA,IAAIC,KAAK,CAACL,KAAD,CAAL,KAAiB,IAArB,EAA2B;AAC9B,UAAM,IAAIG,cAAJ,CAAgB,8BAAhB,EAAgD,eAAhD,EAAiE;AACnEH,MAAAA;AADmE,KAAjE,CAAN;AAGH;;AACD,SAAOM,UAAU,CAACN,KAAD,CAAjB;AACH,CAfD;;AAiBO,MAAMO,MAAM,GAAG,IAAIC,0BAAJ,CAAsB;AACxCC,EAAAA,IAAI,EAAE,QADkC;AAExCC,EAAAA,WAAW,EAAE,sEAF2B;AAGxCC,EAAAA,SAAS,EAAGX,KAAD,IAAgB;AACvB,QAAI;AACA,aAAOD,UAAU,CAACC,KAAD,CAAjB;AACH,KAFD,CAEE,OAAOY,EAAP,EAAW;AACTC,MAAAA,OAAO,CAACC,GAAR,CAAY;AACRC,QAAAA,OAAO,EAAE,8BADD;AAERC,QAAAA,IAAI,EAAE,eAFE;AAGRC,QAAAA,IAAI,EAAE;AACFjB,UAAAA;AADE;AAHE,OAAZ;AAOA,aAAO,IAAP;AACH;AACJ,GAhBuC;AAiBxCD,EAAAA,UAjBwC;AAkBxCmB,EAAAA,YAAY,EAAGC,GAAD,IAAc;AACxB,QAAIA,GAAG,CAACC,IAAJ,KAAaC,eAAKC,GAAlB,IAAyBH,GAAG,CAACC,IAAJ,KAAaC,eAAKE,KAA/C,EAAsD;AAClD,aAAOJ,GAAG,CAACnB,KAAX;AACH;;AAED,UAAM,IAAIwB,KAAJ,CAAW,gCAA+BL,GAAG,CAACnB,KAAM,GAApD,CAAN;AACH;AAxBuC,CAAtB,CAAf","sourcesContent":["import { GraphQLScalarType } from \"graphql\";\nimport { Kind } from \"graphql/language\";\nimport WebinyError from \"@webiny/error\";\n\nconst parseValue = (value: any) => {\n    if (String(value).match(/^0x/) !== null) {\n        throw new WebinyError(\"Value sent must be a non-hex number.\", \"INVALID_VALUE\", {\n            value\n        });\n    } else if (typeof value === \"number\") {\n        return value;\n    } else if (value === null || value === undefined) {\n        return null;\n    } else if (isNaN(value) === true) {\n        throw new WebinyError(\"Value sent must be a number.\", \"INVALID_VALUE\", {\n            value\n        });\n    }\n    return parseFloat(value);\n};\n\nexport const Number = new GraphQLScalarType({\n    name: \"Number\",\n    description: \"A custom input type to be used with numbers. Supports Int and Float.\",\n    serialize: (value: any) => {\n        try {\n            return parseValue(value);\n        } catch (ex) {\n            console.log({\n                message: \"Value sent must be a number.\",\n                code: \"INVALID_VALUE\",\n                data: {\n                    value\n                }\n            });\n            return null;\n        }\n    },\n    parseValue,\n    parseLiteral: (ast: any) => {\n        if (ast.kind === Kind.INT || ast.kind === Kind.FLOAT) {\n            return ast.value;\n        }\n\n        throw new Error(`Expected type Number, found {${ast.value}}`);\n    }\n});\n"]}

package/builtInTypes/RefInputScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["RefInputScalar.ts"],"names":["isMongoId","value","test","Error","RefInput","GraphQLScalarType","name","description","serialize","id","parseValue","parseLiteral","ast","kind","i","fields","length"],"mappings":";;;;;;;AAAA;;AAEA,MAAMA,SAAS,GAAIC,KAAD,IAAwB;AACtC,MAAI,oBAAoBC,IAApB,CAAyBD,KAAzB,CAAJ,EAAqC;AACjC,WAAOA,KAAP;AACH;;AAED,QAAM,IAAIE,KAAJ,CAAU,2BAAV,CAAN;AACH,CAND;;AAQO,MAAMC,QAAQ,GAAG,IAAIC,0BAAJ,CAAsB;AAC1CC,EAAAA,IAAI,EAAE,UADoC;AAE1CC,EAAAA,WAAW,EACP,oGAHsC;AAI1CC,EAAAA,SAAS,EAAEP,KAAK,IAAI;AAChB,QAAI,CAACA,KAAD,IAAUA,KAAK,CAACQ,EAAN,KAAa,IAA3B,EAAiC;AAC7B,aAAO,IAAP;AACH;;AAED,WAAO,OAAOR,KAAP,KAAiB,QAAjB,GAA4BA,KAA5B,GAAoCA,KAAK,CAACQ,EAAjD;AACH,GAVyC;AAW1CC,EAAAA,UAAU,EAAET,KAAK,IAAI;AACjB,QAAI,CAACA,KAAD,IAAUA,KAAK,CAACQ,EAAN,KAAa,IAA3B,EAAiC;AAC7B,aAAO,IAAP;AACH;;AAED,QAAI,OAAOR,KAAP,KAAiB,QAArB,EAA+B;AAC3B,aAAOD,SAAS,CAACC,KAAD,CAAhB;AACH;;AAED,QAAI,QAAQA,KAAZ,EAAmB;AACf,aAAOD,SAAS,CAACC,KAAK,CAACQ,EAAP,CAAhB;AACH;;AAED,UAAM,IAAIN,KAAJ,CAAU,yBAAV,CAAN;AACH,GAzByC;AA0B1CQ,EAAAA,YAAY,EAAEC,GAAG,IAAI;AACjB,QAAIA,GAAG,CAACC,IAAJ,KAAa,aAAjB,EAAgC;AAC5B,aAAOb,SAAS,CAACY,GAAG,CAACX,KAAL,CAAhB;AACH;;AAED,QAAIW,GAAG,CAACC,IAAJ,KAAa,aAAjB,EAAgC;AAC5B,WAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,GAAG,CAACG,MAAJ,CAAWC,MAA/B,EAAuCF,CAAC,EAAxC,EAA4C;AACxC,cAAM;AAAER,UAAAA,IAAF;AAAQL,UAAAA;AAAR,YAAkBW,GAAG,CAACG,MAAJ,CAAWD,CAAX,CAAxB;;AACA,YAAIR,IAAI,CAACL,KAAL,KAAe,IAAnB,EAAyB;AACrB;AACA,iBAAOD,SAAS,CAACC,KAAK,CAACA,KAAP,CAAhB;AACH;AACJ;AACJ;;AAED,UAAM,IAAIE,KAAJ,CAAU,yBAAV,CAAN;AACH;AA1CyC,CAAtB,CAAjB","sourcesContent":["import { GraphQLScalarType } from \"graphql\";\n\nconst isMongoId = (value: any): string => {\n    if (/^[0-9a-fA-F]{24}$/.test(value)) {\n        return value;\n    }\n\n    throw new Error(\"Must be a valid Mongo ID!\");\n};\n\nexport const RefInput = new GraphQLScalarType({\n    name: \"RefInput\",\n    description:\n        \"A custom input type to be used with references. Supports plain ID and `{ id: ID }` Object literal.\",\n    serialize: value => {\n        if (!value || value.id === null) {\n            return null;\n        }\n\n        return typeof value === \"string\" ? value : value.id;\n    },\n    parseValue: value => {\n        if (!value || value.id === null) {\n            return null;\n        }\n\n        if (typeof value === \"string\") {\n            return isMongoId(value);\n        }\n\n        if (\"id\" in value) {\n            return isMongoId(value.id);\n        }\n\n        throw new Error(\"Invalid RefInput value!\");\n    },\n    parseLiteral: ast => {\n        if (ast.kind === \"StringValue\") {\n            return isMongoId(ast.value);\n        }\n\n        if (ast.kind === \"ObjectValue\") {\n            for (let i = 0; i < ast.fields.length; i++) {\n                const { name, value } = ast.fields[i];\n                if (name.value === \"id\") {\n                    // @ts-ignore\n                    return isMongoId(value.value);\n                }\n            }\n        }\n\n        throw new Error(\"Invalid RefInput value!\");\n    }\n});\n"]}

package/builtInTypes/TimeScalar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["TimeScalar.ts"],"names":["re","parseTime","value","match","WebinyError","parsed","split","map","Number","length","hours","minutes","seconds","convertToTime","String","padStart","TimeScalar","GraphQLScalarType","name","description","serialize","parseValue"],"mappings":";;;;;;;;;AAAA;;AACA;;AAEA,MAAMA,EAAE,GAAG,uCAAX;;AAEA,MAAMC,SAAS,GAAIC,KAAD,IAAoB;AAClC,MAAI,CAACA,KAAD,IAAUA,KAAK,CAACC,KAAN,CAAYH,EAAZ,MAAoB,IAAlC,EAAwC;AACpC,UAAM,IAAII,cAAJ,CAAgB,gCAAhB,EAAkD,uBAAlD,EAA2E;AAAEF,MAAAA;AAAF,KAA3E,CAAN;AACH;;AACD,QAAMG,MAAM,GAAGH,KAAK,CAACI,KAAN,CAAY,GAAZ,EAAiBC,GAAjB,CAAqBC,MAArB,CAAf;;AACA,MAAIH,MAAM,CAACI,MAAP,GAAgB,CAApB,EAAuB;AACnB,UAAM,IAAIL,cAAJ,CAAiB,4BAAjB,EAA8C,uBAA9C,EAAuE;AAAEF,MAAAA;AAAF,KAAvE,CAAN;AACH;;AACD,QAAM,CAACQ,KAAD,EAAQC,OAAR,EAAiBC,OAAO,GAAG,CAA3B,IAAgCP,MAAtC;;AACA,MAAIK,KAAK,IAAI,EAAb,EAAiB;AACb,UAAM,IAAIN,cAAJ,CAAiB,qCAAjB,EAAuD,uBAAvD,EAAgF;AAClFF,MAAAA;AADkF,KAAhF,CAAN;AAGH,GAJD,MAIO,IAAIS,OAAO,IAAI,EAAf,EAAmB;AACtB,UAAM,IAAIP,cAAJ,CAAiB,uCAAjB,EAAyD,uBAAzD,EAAkF;AACpFF,MAAAA;AADoF,KAAlF,CAAN;AAGH,GAJM,MAIA,IAAIU,OAAO,IAAI,EAAf,EAAmB;AACtB,UAAM,IAAIR,cAAJ,CAAiB,uCAAjB,EAAyD,uBAAzD,EAAkF;AACpFF,MAAAA;AADoF,KAAlF,CAAN;AAGH;;AACD,SAAO;AACHQ,IAAAA,KADG;AAEHC,IAAAA,OAFG;AAGHC,IAAAA;AAHG,GAAP;AAKH,CA3BD;;AA6BA,MAAMC,aAAa,GAAIX,KAAD,IAA2B;AAC7C,QAAM;AAAEQ,IAAAA,KAAF;AAASC,IAAAA,OAAT;AAAkBC,IAAAA;AAAlB,MAA8BX,SAAS,CAACC,KAAD,CAA7C;AACA,SAAQ,GAAEY,MAAM,CAACJ,KAAD,CAAN,CAAcK,QAAd,CAAuB,CAAvB,EAA0B,GAA1B,CAA+B,IAAGD,MAAM,CAACH,OAAD,CAAN,CAAgBI,QAAhB,CAAyB,CAAzB,EAA4B,GAA5B,CAAiC,IAAGD,MAAM,CAClFF,OADkF,CAAN,CAE9EG,QAF8E,CAErE,CAFqE,EAElE,GAFkE,CAE7D,EAFnB;AAGH,CALD;;AAOO,MAAMC,UAAU,GAAG,IAAIC,0BAAJ,CAAsB;AAC5CC,EAAAA,IAAI,EAAE,MADsC;AAE5CC,EAAAA,WAAW,EAAE,2CAF+B;AAG5C;AACAC,EAAAA,SAAS,EAAEP,aAJiC;AAK5C;AACAQ,EAAAA,UAAU,EAAER;AANgC,CAAtB,CAAnB","sourcesContent":["import { GraphQLScalarType } from \"graphql\";\nimport WebinyError from \"@webiny/error\";\n\nconst re = /^([0-9]{2}):([0-9]{2})(:([0-9]{2}))?$/;\n\nconst parseTime = (value?: string) => {\n    if (!value || value.match(re) === null) {\n        throw new WebinyError(\"Value does not look like time.\", \"TIME_VALIDATION_ERROR\", { value });\n    }\n    const parsed = value.split(\":\").map(Number);\n    if (parsed.length < 2) {\n        throw new WebinyError(`Could not parse the value.`, \"TIME_VALIDATION_ERROR\", { value });\n    }\n    const [hours, minutes, seconds = 0] = parsed;\n    if (hours >= 24) {\n        throw new WebinyError(`There cannot be more than 24 hours.`, \"TIME_VALIDATION_ERROR\", {\n            value\n        });\n    } else if (minutes >= 60) {\n        throw new WebinyError(`There cannot be more than 59 minutes.`, \"TIME_VALIDATION_ERROR\", {\n            value\n        });\n    } else if (seconds >= 60) {\n        throw new WebinyError(`There cannot be more than 59 seconds.`, \"TIME_VALIDATION_ERROR\", {\n            value\n        });\n    }\n    return {\n        hours,\n        minutes,\n        seconds\n    };\n};\n\nconst convertToTime = (value: string): string => {\n    const { hours, minutes, seconds } = parseTime(value);\n    return `${String(hours).padStart(2, \"0\")}:${String(minutes).padStart(2, \"0\")}:${String(\n        seconds\n    ).padStart(2, \"0\")}`;\n};\n\nexport const TimeScalar = new GraphQLScalarType({\n    name: \"Time\",\n    description: \"A custom type to support time-only input.\",\n    // sending to client\n    serialize: convertToTime,\n    // received from client\n    parseValue: convertToTime\n});\n"]}

package/builtInTypes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"names":[],"mappings":";;;;;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA","sourcesContent":["export * from \"./AnyScalar\";\nexport * from \"./DateScalar\";\nexport * from \"./DateTimeScalar\";\nexport * from \"./DateTimeZScalar\";\nexport * from \"./JsonScalar\";\nexport * from \"./LongScalar\";\nexport * from \"./NumberScalar\";\nexport * from \"./RefInputScalar\";\nexport * from \"./TimeScalar\";\n"]}

package/createGraphQLHandler.js

@@ -33,7 +33,7 @@ const DEFAULT_HEADERS = _objectSpread({
 const DEFAULT_CACHE_MAX_AGE = 30758400; // 1 year
 
 var _default = (options = {}) => {
-  let schema;
+  let schema = undefined;
   const debug = (0, _boolean.boolean)(options.debug);
   return [...(debug ? (0, _debugPlugins.default)() : []), {
     type: "handler",

package/createGraphQLHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createGraphQLHandler.ts"],"names":["DEFAULT_HEADERS","DEFAULT_CACHE_MAX_AGE","options","schema","undefined","debug","type","name","handle","context","next","http","request","method","response","statusCode","headers","body","JSON","parse","result","stringify"],"mappings":";;;;;;;;;;;AAEA;;AAEA;;AAEA;;AACA;;AACA;;;;;;AAGA,MAAMA,eAAe;AACjB,kBAAgB,kBADC;AAEjB,iCAA+B,GAFd;AAGjB,kCAAgC,GAHf;AAIjB,kCAAgC;AAJf,GAKd,qCALc,CAArB;;AAQA,MAAMC,qBAAqB,GAAG,QAA9B,C,CAAwC;;eAEzB,CAACC,OAA8B,GAAG,EAAlC,KAA2D;AACtE,MAAIC,MAAiC,GAAGC,SAAxC;AAEA,QAAMC,KAAK,GAAG,sBAAQH,OAAO,CAACG,KAAhB,CAAd;AAEA,SAAO,CACH,IAAIA,KAAK,GAAG,4BAAH,GAAoB,EAA7B,CADG,EAEH;AACIC,IAAAA,IAAI,EAAE,SADV;AAEIC,IAAAA,IAAI,EAAE,iBAFV;;AAGI,UAAMC,MAAN,CAAaC,OAAb,EAA6CC,IAA7C,EAAmD;AAC/C,YAAM;AAAEC,QAAAA;AAAF,UAAWF,OAAjB;;AACA,UAAI,CAACE,IAAL,EAAW;AACP,eAAOD,IAAI,EAAX;AACH;;AAED,UAAIC,IAAI,CAACC,OAAL,CAAaC,MAAb,KAAwB,SAA5B,EAAuC;AACnC,eAAOF,IAAI,CAACG,QAAL,CAAc;AACjBC,UAAAA,UAAU,EAAE,GADK;AAEjBC,UAAAA,OAAO,kCACAhB,eADA;AAEH,6BAAiB,qBAAqBC;AAFnC;AAFU,SAAd,CAAP;AAOH;;AAED,UAAIU,IAAI,CAACC,OAAL,CAAaC,MAAb,KAAwB,MAA5B,EAAoC;AAChC,eAAOH,IAAI,EAAX;AACH;;AAED,UAAI,CAACP,MAAL,EAAa;AACTA,QAAAA,MAAM,GAAG,8CAAoBM,OAApB,CAAT;AACH;;AAED,YAAMQ,IAAI,GAAGC,IAAI,CAACC,KAAL,CAAWR,IAAI,CAACC,OAAL,CAAaK,IAAxB,CAAb;AACA,YAAMG,MAAM,GAAG,MAAM,iCAAmBH,IAAnB,EAAyBd,MAAzB,EAAiCM,OAAjC,CAArB;AAEA,aAAOE,IAAI,CAACG,QAAL,CAAc;AACjBG,QAAAA,IAAI,EAAEC,IAAI,CAACG,SAAL,CAAeD,MAAf,CADW;AAEjBL,QAAAA,UAAU,EAAE,GAFK;AAGjBC,QAAAA,OAAO,EAAEhB;AAHQ,OAAd,CAAP;AAKH;;AAnCL,GAFG,CAAP;AAwCH,C","sourcesContent":["import { HandlerPlugin, Context } from \"@webiny/handler/types\";\nimport { HttpContext } from \"@webiny/handler-http/types\";\nimport { boolean } from \"boolean\";\nimport { HandlerGraphQLOptions } from \"./types\";\nimport { createGraphQLSchema } from \"./createGraphQLSchema\";\nimport { PluginCollection } from \"@webiny/plugins/types\";\nimport debugPlugins from \"./debugPlugins\";\nimport processRequestBody from \"./processRequestBody\";\nimport { getWebinyVersionHeaders } from \"@webiny/utils\";\nimport { GraphQLSchema } from \"graphql\";\n\nconst DEFAULT_HEADERS = {\n    \"Content-Type\": \"application/json\",\n    \"Access-Control-Allow-Origin\": \"*\",\n    \"Access-Control-Allow-Headers\": \"*\",\n    \"Access-Control-Allow-Methods\": \"OPTIONS,POST\",\n    ...getWebinyVersionHeaders()\n};\n\nconst DEFAULT_CACHE_MAX_AGE = 30758400; // 1 year\n\nexport default (options: HandlerGraphQLOptions = {}): PluginCollection => {\n    let schema: GraphQLSchema | undefined = undefined;\n\n    const debug = boolean(options.debug);\n\n    return [\n        ...(debug ? debugPlugins() : []),\n        {\n            type: \"handler\",\n            name: \"handler-graphql\",\n            async handle(context: Context & HttpContext, next) {\n                const { http } = context;\n                if (!http) {\n                    return next();\n                }\n\n                if (http.request.method === \"OPTIONS\") {\n                    return http.response({\n                        statusCode: 204,\n                        headers: {\n                            ...DEFAULT_HEADERS,\n                            \"Cache-Control\": \"public, max-age=\" + DEFAULT_CACHE_MAX_AGE\n                        }\n                    });\n                }\n\n                if (http.request.method !== \"POST\") {\n                    return next();\n                }\n\n                if (!schema) {\n                    schema = createGraphQLSchema(context);\n                }\n\n                const body = JSON.parse(http.request.body);\n                const result = await processRequestBody(body, schema, context);\n\n                return http.response({\n                    body: JSON.stringify(result),\n                    statusCode: 200,\n                    headers: DEFAULT_HEADERS\n                });\n            }\n        } as HandlerPlugin\n    ];\n};\n"]}

package/createGraphQLSchema.js

@@ -51,7 +51,14 @@ const createGraphQLSchema = context => {
 
   for (let i = 0; i < gqlPlugins.length; i++) {
     const plugin = gqlPlugins[i];
-    typeDefs.push(plugin.schema.typeDefs);
+    /**
+     * TODO @ts-refactor
+     * Figure out correct tyeps on typeDefs and resolvers
+     */
+    // @ts-ignore
+
+    typeDefs.push(plugin.schema.typeDefs); // @ts-ignore
+
     resolvers.push(plugin.schema.resolvers);
   }
 

package/createGraphQLSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createGraphQLSchema.ts"],"names":["createGraphQLSchema","context","scalars","plugins","byType","map","item","scalar","typeDefs","name","join","resolvers","reduce","acc","s","JSON","JsonScalar","Long","LongScalar","RefInput","Number","NumberScalar","Any","AnyScalar","DateTime","DateTimeScalar","Date","DateScalar","Time","TimeScalar","gqlPlugins","i","length","plugin","push","schema","inheritResolversFromInterfaces"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AAGA;;;;;;AAYO,MAAMA,mBAAmB,GAAIC,OAAD,IAA0B;AACzD,QAAMC,OAAO,GAAGD,OAAO,CAACE,OAAR,CACXC,MADW,CACiB,gBADjB,EAEXC,GAFW,CAEPC,IAAI,IAAIA,IAAI,CAACC,MAFN,CAAhB;AAIA,QAAMC,QAAQ,GAAG,CACb,wBAAI;AACZ;AACA;AACA,cAAcN,OAAO,CAACG,GAAR,CAAYE,MAAM,IAAK,UAASA,MAAM,CAACE,IAAK,EAA5C,EAA+CC,IAA/C,CAAoD,GAApD,CAAyD;AACvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAbqB,CAAjB;AAgBA,QAAMC,SAAS,GAAG,iCAEPT,OAAO,CAACU,MAAR,CAAe,CAACC,GAAD,EAAMC,CAAN,KAAY;AAC1BD,IAAAA,GAAG,CAACC,CAAC,CAACL,IAAH,CAAH,GAAcK,CAAd;AACA,WAAOD,GAAP;AACH,GAHE,EAGA,EAHA,CAFO;AAMVE,IAAAA,IAAI,EAAEC,wBANI;AAOVC,IAAAA,IAAI,EAAEC,wBAPI;AAQVC,IAAAA,QAAQ,EAARA,sBARU;AASVC,IAAAA,MAAM,EAAEC,oBATE;AAUVC,IAAAA,GAAG,EAAEC,iBAVK;AAWVC,IAAAA,QAAQ,EAAEC,4BAXA;AAYVC,IAAAA,IAAI,EAAEC,wBAZI;AAaVC,IAAAA,IAAI,EAAEC;AAbI,KAAlB;AAiBA,QAAMC,UAAU,GAAG7B,OAAO,CAACE,OAAR,CAAgBC,MAAhB,CAA4C,gBAA5C,CAAnB;;AACA,OAAK,IAAI2B,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGD,UAAU,CAACE,MAA/B,EAAuCD,CAAC,EAAxC,EAA4C;AACxC,UAAME,MAAM,GAAGH,UAAU,CAACC,CAAD,CAAzB;AACA;AACR;AACA;AACA;AACQ;;AACAvB,IAAAA,QAAQ,CAAC0B,IAAT,CAAcD,MAAM,CAACE,MAAP,CAAc3B,QAA5B,EAPwC,CAQxC;;AACAG,IAAAA,SAAS,CAACuB,IAAV,CAAeD,MAAM,CAACE,MAAP,CAAcxB,SAA7B;AACH;;AAED,SAAO,kCAAqB;AACxBH,IAAAA,QADwB;AAExBG,IAAAA,SAFwB;AAGxByB,IAAAA,8BAA8B,EAAE;AAHR,GAArB,CAAP;AAKH,CAxDM","sourcesContent":["import gql from \"graphql-tag\";\nimport { makeExecutableSchema } from \"@graphql-tools/schema\";\nimport { GraphQLScalarPlugin, GraphQLSchemaPlugin } from \"./types\";\nimport { HttpContext } from \"@webiny/handler-http/types\";\nimport {\n    RefInput,\n    Number as NumberScalar,\n    Any as AnyScalar,\n    DateScalar,\n    DateTimeScalar,\n    JsonScalar,\n    TimeScalar,\n    LongScalar\n} from \"./builtInTypes\";\nimport { GraphQLScalarType } from \"graphql/type/definition\";\n\nexport const createGraphQLSchema = (context: HttpContext) => {\n    const scalars = context.plugins\n        .byType<GraphQLScalarPlugin>(\"graphql-scalar\")\n        .map(item => item.scalar);\n\n    const typeDefs = [\n        gql`\n            type Query\n            type Mutation\n            ${scalars.map(scalar => `scalar ${scalar.name}`).join(\" \")}\n            scalar JSON\n            scalar Long\n            scalar RefInput\n            scalar Number\n            scalar Any\n            scalar Date\n            scalar DateTime\n            scalar Time\n        `\n    ];\n\n    const resolvers = [\n        {\n            ...scalars.reduce((acc, s) => {\n                acc[s.name] = s;\n                return acc;\n            }, {} as Record<string, GraphQLScalarType>),\n            JSON: JsonScalar,\n            Long: LongScalar,\n            RefInput,\n            Number: NumberScalar,\n            Any: AnyScalar,\n            DateTime: DateTimeScalar,\n            Date: DateScalar,\n            Time: TimeScalar\n        }\n    ];\n\n    const gqlPlugins = context.plugins.byType<GraphQLSchemaPlugin>(\"graphql-schema\");\n    for (let i = 0; i < gqlPlugins.length; i++) {\n        const plugin = gqlPlugins[i];\n        /**\n         * TODO @ts-refactor\n         * Figure out correct tyeps on typeDefs and resolvers\n         */\n        // @ts-ignore\n        typeDefs.push(plugin.schema.typeDefs);\n        // @ts-ignore\n        resolvers.push(plugin.schema.resolvers);\n    }\n\n    return makeExecutableSchema({\n        typeDefs,\n        resolvers,\n        inheritResolversFromInterfaces: true\n    });\n};\n"]}

package/debugPlugins.d.ts

@@ -1,11 +1,12 @@
 import { GraphQLAfterQueryPlugin, GraphQLBeforeQueryPlugin } from "./types";
 import { Context, ContextPlugin } from "@webiny/handler/types";
+interface Log {
+    method: string;
+    args: any;
+}
 interface DebugContext extends Context {
     debug: {
-        logs?: {
-            method: string;
-            args: any;
-        }[];
+        logs?: Log[];
     };
 }
 declare const _default: () => (ContextPlugin<DebugContext, Context, Context, Context, Context, Context, Context, Context, Context, Context> | GraphQLBeforeQueryPlugin<DebugContext> | GraphQLAfterQueryPlugin<DebugContext>)[];

package/debugPlugins.js

@@ -11,8 +11,14 @@ var _default = () => [{
   type: "context",
 
   apply(context) {
-    context.debug = context.debug || {};
-    context.debug.logs = [];
+    if (!context.debug) {
+      context.debug = {};
+    }
+
+    if (!context.debug.logs) {
+      context.debug.logs = [];
+    }
+
     (0, _interceptConsole.interceptConsole)((method, args) => {
       context.debug.logs.push({
         method,

package/debugPlugins.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["debugPlugins.ts"],"names":["type","apply","context","debug","logs","method","args","push","result","console"],"mappings":";;;;;;;AAAA;;eAce,MAAM,CACjB;AACIA,EAAAA,IAAI,EAAE,SADV;;AAEIC,EAAAA,KAAK,CAACC,OAAD,EAAU;AACX,QAAI,CAACA,OAAO,CAACC,KAAb,EAAoB;AAChBD,MAAAA,OAAO,CAACC,KAAR,GAAgB,EAAhB;AACH;;AACD,QAAI,CAACD,OAAO,CAACC,KAAR,CAAcC,IAAnB,EAAyB;AACrBF,MAAAA,OAAO,CAACC,KAAR,CAAcC,IAAd,GAAqB,EAArB;AACH;;AACD,4CAAiB,CAACC,MAAD,EAASC,IAAT,KAAkB;AAC9BJ,MAAAA,OAAO,CAACC,KAAR,CAAcC,IAAf,CAA8BG,IAA9B,CAAmC;AAAEF,QAAAA,MAAF;AAAUC,QAAAA;AAAV,OAAnC;AACH,KAFD;AAGH;;AAZL,CADiB,EAejB;AACIN,EAAAA,IAAI,EAAE,sBADV;;AAEIC,EAAAA,KAAK,CAAC;AAAEC,IAAAA;AAAF,GAAD,EAAc;AACf;AACAA,IAAAA,OAAO,CAACC,KAAR,CAAcC,IAAd,GAAqB,EAArB;AACH;;AALL,CAfiB,EAsBjB;AACIJ,EAAAA,IAAI,EAAE,qBADV;;AAEIC,EAAAA,KAAK,CAAC;AAAEO,IAAAA,MAAF;AAAUN,IAAAA;AAAV,GAAD,EAAsB;AACvBM,IAAAA,MAAM,CAAC,YAAD,CAAN,GAAuB;AAAEC,MAAAA,OAAO,EAAEP,OAAO,CAACC,KAAR,CAAcC,IAAd,IAAsB;AAAjC,KAAvB;AACH;;AAJL,CAtBiB,C","sourcesContent":["import { interceptConsole } from \"./interceptConsole\";\nimport { GraphQLAfterQueryPlugin, GraphQLBeforeQueryPlugin } from \"./types\";\nimport { Context, ContextPlugin } from \"@webiny/handler/types\";\n\ninterface Log {\n    method: string;\n    args: any;\n}\ninterface DebugContext extends Context {\n    debug: {\n        logs?: Log[];\n    };\n}\n\nexport default () => [\n    {\n        type: \"context\",\n        apply(context) {\n            if (!context.debug) {\n                context.debug = {};\n            }\n            if (!context.debug.logs) {\n                context.debug.logs = [];\n            }\n            interceptConsole((method, args) => {\n                (context.debug.logs as Log[]).push({ method, args });\n            });\n        }\n    } as ContextPlugin<DebugContext>,\n    {\n        type: \"graphql-before-query\",\n        apply({ context }) {\n            // Empty logs\n            context.debug.logs = [];\n        }\n    } as GraphQLBeforeQueryPlugin<DebugContext>,\n    {\n        type: \"graphql-after-query\",\n        apply({ result, context }) {\n            result[\"extensions\"] = { console: context.debug.logs || [] };\n        }\n    } as GraphQLAfterQueryPlugin<DebugContext>\n];\n"]}

package/errors.d.ts

@@ -1,4 +1,4 @@
-import Error from "@webiny/error";
-export declare class NotFoundError extends Error {
+import WebinyError from "@webiny/error";
+export declare class NotFoundError extends WebinyError {
     constructor(message?: string);
 }

package/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["errors.ts"],"names":["NotFoundError","WebinyError","constructor","message"],"mappings":";;;;;;;;;AAAA;;AAEO,MAAMA,aAAN,SAA4BC,cAA5B,CAAwC;AAC3CC,EAAAA,WAAW,CAACC,OAAO,GAAG,YAAX,EAAyB;AAChC,UAAMA,OAAN,EAAe,WAAf;AACH;;AAH0C","sourcesContent":["import WebinyError from \"@webiny/error\";\n\nexport class NotFoundError extends WebinyError {\n    constructor(message = \"Not found.\") {\n        super(message, \"NOT_FOUND\");\n    }\n}\n"]}

package/index.d.ts

@@ -1,9 +1,16 @@
 import { HandlerGraphQLOptions } from "./types";
 import { Context } from "@webiny/handler/types";
 import { GraphQLFieldResolver } from "./types";
+/**
+ * Can be anything.
+ * TODO: Figure out if required at all.
+ */
+interface Callable {
+    (params: any): any;
+}
 export * from "./errors";
 export * from "./responses";
 declare const _default: (options?: HandlerGraphQLOptions) => import("@webiny/plugins/types").PluginCollection[];
 export default _default;
-export declare const pipe: <TSource = any, TArgs = Record<string, any>, TContext = Context>(...fns: any[]) => (resolver: import("graphql").GraphQLFieldResolver<TSource, TContext, TArgs>) => any;
-export declare const compose: <TSource = any, TArgs = Record<string, any>, TContext = Context>(...fns: any[]) => (resolver: import("graphql").GraphQLFieldResolver<TSource, TContext, TArgs>) => any;
+export declare const pipe: <TSource = any, TArgs = Record<string, any>, TContext = Context>(...fns: Callable[]) => (resolver: GraphQLFieldResolver<TSource, TArgs, TContext>) => GraphQLFieldResolver<TSource, TArgs, TContext>;
+export declare const compose: <TSource = any, TArgs = Record<string, any>, TContext = Context>(...fns: Callable[]) => (resolver: GraphQLFieldResolver<TSource, TArgs, TContext>) => GraphQLFieldResolver<TSource, TArgs, TContext>;

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"names":["options","pipe","fns","resolver","reduce","v","f","compose","reduceRight"],"mappings":";;;;;;;;;;;;;AACA;;AAWA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;AACA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;eAEe,CAACA,OAA8B,GAAG,EAAlC,KAAyC,CAAC,mCAAqBA,OAArB,CAAD,C;;;;AAEjD,MAAMC,IAAI,GACb,CAAiE,GAAGC,GAApE,KACCC,QAAD,IACID,GAAG,CAACE,MAAJ,CAAW,CAACC,CAAD,EAAIC,CAAJ,KAAUA,CAAC,CAACD,CAAD,CAAtB,EAA2BF,QAA3B,CAHD;;;;AAKA,MAAMI,OAAO,GAChB,CAAiE,GAAGL,GAApE,KACCC,QAAD,IACID,GAAG,CAACM,WAAJ,CAAgB,CAACH,CAAD,EAAIC,CAAJ,KAAUA,CAAC,CAACD,CAAD,CAA3B,EAAgCF,QAAhC,CAHD","sourcesContent":["import { HandlerGraphQLOptions } from \"./types\";\nimport createGraphQLHandler from \"./createGraphQLHandler\";\nimport { Context } from \"@webiny/handler/types\";\nimport { GraphQLFieldResolver } from \"./types\";\n\n/**\n * Can be anything.\n * TODO: Figure out if required at all.\n */\ninterface Callable {\n    (params: any): any;\n}\nexport * from \"./errors\";\nexport * from \"./responses\";\n\nexport default (options: HandlerGraphQLOptions = {}) => [createGraphQLHandler(options)];\n\nexport const pipe =\n    <TSource = any, TArgs = Record<string, any>, TContext = Context>(...fns: Callable[]) =>\n    (resolver: GraphQLFieldResolver<TSource, TArgs, TContext>) =>\n        fns.reduce((v, f) => f(v), resolver);\n\nexport const compose =\n    <TSource = any, TArgs = Record<string, any>, TContext = Context>(...fns: Callable[]) =>\n    (resolver: GraphQLFieldResolver<TSource, TArgs, TContext>) =>\n        fns.reduceRight((v, f) => f(v), resolver);\n"]}

package/interceptConsole.d.ts

@@ -1 +1,5 @@
-export declare const interceptConsole: (callback: any) => void;
+interface InterceptConsoleCallable {
+    (method: string, args: any[]): void;
+}
+export declare const interceptConsole: (callback: InterceptConsoleCallable) => void;
+export {};

package/interceptConsole.js

@@ -10,19 +10,23 @@ const skipOriginal = ["table"];
 
 const restoreOriginalMethods = () => {
   for (const method of consoleMethods) {
+    // @ts-ignore
     console[method] = originalMethods[method];
   }
 };
 
 const interceptConsole = callback => {
+  // @ts-ignore
   if (console["__WEBINY__"] === true) {
     restoreOriginalMethods();
-  }
+  } // @ts-ignore
+
 
   console["__WEBINY__"] = true;
 
   for (const method of consoleMethods) {
-    originalMethods[method] = console[method];
+    // @ts-ignore
+    originalMethods[method] = console[method]; // @ts-ignore
 
     console[method] = (...args) => {
       callback(method, args);

package/interceptConsole.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["interceptConsole.ts"],"names":["consoleMethods","originalMethods","skipOriginal","restoreOriginalMethods","method","console","interceptConsole","callback","args","includes"],"mappings":";;;;;;AAAA,MAAMA,cAAc,GAAG,CACnB,QADmB,EAEnB,OAFmB,EAGnB,KAHmB,EAInB,OAJmB,EAKnB,OALmB,EAMnB,gBANmB,EAOnB,UAPmB,EAQnB,MARmB,EASnB,KATmB,EAUnB,OAVmB,EAWnB,MAXmB,CAAvB;AAcA,MAAMC,eAAoC,GAAG,EAA7C;AACA,MAAMC,YAAsB,GAAG,CAAC,OAAD,CAA/B;;AAEA,MAAMC,sBAAsB,GAAG,MAAM;AACjC,OAAK,MAAMC,MAAX,IAAqBJ,cAArB,EAAqC;AACjC;AACAK,IAAAA,OAAO,CAACD,MAAD,CAAP,GAAkBH,eAAe,CAACG,MAAD,CAAjC;AACH;AACJ,CALD;;AAWO,MAAME,gBAAgB,GAAIC,QAAD,IAAwC;AACpE;AACA,MAAIF,OAAO,CAAC,YAAD,CAAP,KAA0B,IAA9B,EAAoC;AAChCF,IAAAA,sBAAsB;AACzB,GAJmE,CAMpE;;;AACAE,EAAAA,OAAO,CAAC,YAAD,CAAP,GAAwB,IAAxB;;AAEA,OAAK,MAAMD,MAAX,IAAqBJ,cAArB,EAAqC;AACjC;AACAC,IAAAA,eAAe,CAACG,MAAD,CAAf,GAA0BC,OAAO,CAACD,MAAD,CAAjC,CAFiC,CAGjC;;AACAC,IAAAA,OAAO,CAACD,MAAD,CAAP,GAAkB,CAAC,GAAGI,IAAJ,KAAa;AAC3BD,MAAAA,QAAQ,CAACH,MAAD,EAASI,IAAT,CAAR;;AACA,UAAIN,YAAY,CAACO,QAAb,CAAsBL,MAAtB,CAAJ,EAAmC;AAC/B;AACH;;AACDH,MAAAA,eAAe,CAACG,MAAD,CAAf,CAAwB,GAAGI,IAA3B;AACH,KAND;AAOH;AACJ,CArBM","sourcesContent":["const consoleMethods = [\n    \"assert\",\n    \"debug\",\n    \"dir\",\n    \"error\",\n    \"group\",\n    \"groupCollapsed\",\n    \"groupEnd\",\n    \"info\",\n    \"log\",\n    \"table\",\n    \"warn\"\n];\n\nconst originalMethods: Record<string, any> = {};\nconst skipOriginal: string[] = [\"table\"];\n\nconst restoreOriginalMethods = () => {\n    for (const method of consoleMethods) {\n        // @ts-ignore\n        console[method] = originalMethods[method];\n    }\n};\n\ninterface InterceptConsoleCallable {\n    (method: string, args: any[]): void;\n}\n\nexport const interceptConsole = (callback: InterceptConsoleCallable) => {\n    // @ts-ignore\n    if (console[\"__WEBINY__\"] === true) {\n        restoreOriginalMethods();\n    }\n\n    // @ts-ignore\n    console[\"__WEBINY__\"] = true;\n\n    for (const method of consoleMethods) {\n        // @ts-ignore\n        originalMethods[method] = console[method];\n        // @ts-ignore\n        console[method] = (...args) => {\n            callback(method, args);\n            if (skipOriginal.includes(method)) {\n                return;\n            }\n            originalMethods[method](...args);\n        };\n    }\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/handler-graphql",
-	"version": "5.23.1",
+	"version": "5.25.0-beta.0",
 	"main": "index.js",
 	"license": "MIT",
 	"repository": {
@@ -14,14 +14,14 @@
 		"Adrian Smijulj <adrian@webiny.com>"
 	],
 	"dependencies": {
-		"@babel/runtime": "7.16.7",
+		"@babel/runtime": "7.17.2",
 		"@graphql-tools/schema": "7.1.5",
-		"@webiny/error": "5.23.1",
-		"@webiny/handler": "5.23.1",
-		"@webiny/handler-http": "5.23.1",
-		"@webiny/plugins": "5.23.1",
-		"@webiny/utils": "5.23.1",
-		"boolean": "3.1.4",
+		"@webiny/error": "5.25.0-beta.0",
+		"@webiny/handler": "5.25.0-beta.0",
+		"@webiny/handler-http": "5.25.0-beta.0",
+		"@webiny/plugins": "5.25.0-beta.0",
+		"@webiny/utils": "5.25.0-beta.0",
+		"boolean": "3.2.0",
 		"graphql": "15.8.0",
 		"graphql-scalars": "1.12.0",
 		"graphql-tag": "2.12.6"
@@ -30,13 +30,13 @@
 		"@babel/cli": "^7.16.0",
 		"@babel/core": "^7.16.0",
 		"@babel/preset-env": "^7.16.4",
-		"@webiny/cli": "^5.23.1",
-		"@webiny/handler-args": "^5.23.1",
-		"@webiny/project-utils": "^5.23.1",
+		"@webiny/cli": "^5.25.0-beta.0",
+		"@webiny/handler-args": "^5.25.0-beta.0",
+		"@webiny/project-utils": "^5.25.0-beta.0",
 		"jest": "^26.6.3",
 		"jest-mock-console": "^1.0.0",
 		"rimraf": "^3.0.2",
-		"typescript": "^4.1.3"
+		"typescript": "4.5.5"
 	},
 	"publishConfig": {
 		"access": "public",
@@ -46,5 +46,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "a726d09d2647d13e5a4f376cef23463564ef7ca0"
+	"gitHead": "2d3e7833575e88fde77d84e5490e746933a5ec28"
 }

package/plugins/GraphQLSchemaPlugin.d.ts

@@ -6,7 +6,7 @@ export interface GraphQLSchemaPluginConfig<TContext> {
     resolvers?: Resolvers<TContext>;
 }
 export declare class GraphQLSchemaPlugin<TContext = Context> extends Plugin {
-    static readonly type = "graphql-schema";
+    static readonly type: string;
     private config;
     constructor(config: GraphQLSchemaPluginConfig<TContext>);
     get schema(): GraphQLSchemaDefinition<TContext>;

package/plugins/GraphQLSchemaPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["GraphQLSchemaPlugin.ts"],"names":["GraphQLSchemaPlugin","Plugin","constructor","config","schema","typeDefs","resolvers"],"mappings":";;;;;;;;;;;AAAA;;AASO,MAAMA,mBAAN,SAAsDC,eAAtD,CAA6D;AAIhEC,EAAAA,WAAW,CAACC,MAAD,EAA8C;AACrD;AADqD;AAErD,SAAKA,MAAL,GAAcA,MAAd;AACH;;AAES,MAANC,MAAM,GAAsC;AAC5C,WAAO;AACHC,MAAAA,QAAQ,EAAE,KAAKF,MAAL,CAAYE,QAAZ,IAAwB,EAD/B;AAEHC,MAAAA,SAAS,EAAE,KAAKH,MAAL,CAAYG;AAFpB,KAAP;AAIH;;AAd+D;;;8BAAvDN,mB,UACsC,gB","sourcesContent":["import { Plugin } from \"@webiny/plugins\";\nimport { GraphQLSchemaDefinition, Resolvers, Types } from \"~/types\";\nimport { Context } from \"@webiny/handler/types\";\n\nexport interface GraphQLSchemaPluginConfig<TContext> {\n    typeDefs?: Types;\n    resolvers?: Resolvers<TContext>;\n}\n\nexport class GraphQLSchemaPlugin<TContext = Context> extends Plugin {\n    public static override readonly type: string = \"graphql-schema\";\n    private config: GraphQLSchemaPluginConfig<TContext>;\n\n    constructor(config: GraphQLSchemaPluginConfig<TContext>) {\n        super();\n        this.config = config;\n    }\n\n    get schema(): GraphQLSchemaDefinition<TContext> {\n        return {\n            typeDefs: this.config.typeDefs || \"\",\n            resolvers: this.config.resolvers\n        };\n    }\n}\n"]}

package/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.ts"],"names":[],"mappings":";;;;;;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA","sourcesContent":["export * from \"./GraphQLSchemaPlugin\";\n"]}

package/processRequestBody.d.ts

@@ -1,3 +1,5 @@
+import { ExecutionResult, GraphQLSchema } from "graphql";
+import { GraphQLRequestBody } from "./types";
 import { Context } from "@webiny/handler/types";
-declare const _default: (requestBody: any, schema: any, context: Context) => Promise<any>;
+declare const _default: (requestBody: GraphQLRequestBody | GraphQLRequestBody[], schema: GraphQLSchema, context: Context) => Promise<ExecutionResult[] | ExecutionResult>;
 export default _default;

package/processRequestBody.js

@@ -31,19 +31,17 @@ const processRequestBody = async (body, schema, context) => {
 };
 
 var _default = async (requestBody, schema, context) => {
-  let result;
-
-  if (Array.isArray(requestBody)) {
-    result = [];
+  if (Array.isArray(requestBody) === true) {
+    const result = [];
 
     for (let i = 0; i < requestBody.length; i++) {
       result.push(await processRequestBody(requestBody[i], schema, context));
     }
-  } else {
-    result = await processRequestBody(requestBody, schema, context);
+
+    return result;
   }
 
-  return result;
+  return await processRequestBody(requestBody, schema, context);
 };
 
 exports.default = _default;

package/processRequestBody.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["processRequestBody.ts"],"names":["processRequestBody","body","schema","context","query","variables","operationName","plugins","byType","forEach","pl","apply","result","requestBody","Array","isArray","i","length","push"],"mappings":";;;;;;;AAAA;;AAIA,MAAMA,kBAAkB,GAAG,OACvBC,IADuB,EAEvBC,MAFuB,EAGvBC,OAHuB,KAItB;AACD,QAAM;AAAEC,IAAAA,KAAF;AAASC,IAAAA,SAAT;AAAoBC,IAAAA;AAApB,MAAsCL,IAA5C;AAEAE,EAAAA,OAAO,CAACI,OAAR,CACKC,MADL,CACsC,sBADtC,EAEKC,OAFL,CAEaC,EAAE,IAAIA,EAAE,CAACC,KAAH,CAAS;AAAEV,IAAAA,IAAF;AAAQC,IAAAA,MAAR;AAAgBC,IAAAA;AAAhB,GAAT,CAFnB;AAIA,QAAMS,MAAM,GAAG,MAAM,sBAAQV,MAAR,EAAgBE,KAAhB,EAAuB,EAAvB,EAA2BD,OAA3B,EAAoCE,SAApC,EAA+CC,aAA/C,CAArB;AAEAH,EAAAA,OAAO,CAACI,OAAR,CAAgBC,MAAhB,CAAgD,qBAAhD,EAAuEC,OAAvE,CAA+EC,EAAE,IAAI;AACjFA,IAAAA,EAAE,CAACC,KAAH,CAAS;AAAEC,MAAAA,MAAF;AAAUX,MAAAA,IAAV;AAAgBC,MAAAA,MAAhB;AAAwBC,MAAAA;AAAxB,KAAT;AACH,GAFD;AAIA,SAAOS,MAAP;AACH,CAlBD;;eAoBe,OACXC,WADW,EAEXX,MAFW,EAGXC,OAHW,KAIoC;AAC/C,MAAIW,KAAK,CAACC,OAAN,CAAcF,WAAd,MAA+B,IAAnC,EAAyC;AACrC,UAAMD,MAAyB,GAAG,EAAlC;;AACA,SAAK,IAAII,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAIH,WAAD,CAAsCI,MAA1D,EAAkED,CAAC,EAAnE,EAAuE;AACnEJ,MAAAA,MAAM,CAACM,IAAP,CACI,MAAMlB,kBAAkB,CAAEa,WAAD,CAAsCG,CAAtC,CAAD,EAA2Cd,MAA3C,EAAmDC,OAAnD,CAD5B;AAGH;;AACD,WAAOS,MAAP;AACH;;AACD,SAAO,MAAMZ,kBAAkB,CAACa,WAAD,EAAoCX,MAApC,EAA4CC,OAA5C,CAA/B;AACH,C","sourcesContent":["import { ExecutionResult, graphql, GraphQLSchema } from \"graphql\";\nimport { GraphQLAfterQueryPlugin, GraphQLBeforeQueryPlugin, GraphQLRequestBody } from \"./types\";\nimport { Context } from \"@webiny/handler/types\";\n\nconst processRequestBody = async (\n    body: GraphQLRequestBody,\n    schema: GraphQLSchema,\n    context: Context\n) => {\n    const { query, variables, operationName } = body;\n\n    context.plugins\n        .byType<GraphQLBeforeQueryPlugin>(\"graphql-before-query\")\n        .forEach(pl => pl.apply({ body, schema, context }));\n\n    const result = await graphql(schema, query, {}, context, variables, operationName);\n\n    context.plugins.byType<GraphQLAfterQueryPlugin>(\"graphql-after-query\").forEach(pl => {\n        pl.apply({ result, body, schema, context });\n    });\n\n    return result;\n};\n\nexport default async (\n    requestBody: GraphQLRequestBody | GraphQLRequestBody[],\n    schema: GraphQLSchema,\n    context: Context\n): Promise<ExecutionResult[] | ExecutionResult> => {\n    if (Array.isArray(requestBody) === true) {\n        const result: ExecutionResult[] = [];\n        for (let i = 0; i < (requestBody as GraphQLRequestBody[]).length; i++) {\n            result.push(\n                await processRequestBody((requestBody as GraphQLRequestBody[])[i], schema, context)\n            );\n        }\n        return result;\n    }\n    return await processRequestBody(requestBody as GraphQLRequestBody, schema, context);\n};\n"]}

package/responses.d.ts

@@ -1,14 +1,16 @@
-declare type ErrorResponseParams = {
+export interface ErrorResponseParams {
+    message: string;
     code?: string;
-    message?: string;
     data?: any;
-};
+    stack?: string | null;
+}
 export declare class ErrorResponse {
-    data: any;
-    error: {
+    readonly data: null;
+    readonly error: {
         code: string;
         message: string;
-        data?: any;
+        data: any;
+        stack: string | null;
     };
     constructor(params: ErrorResponseParams);
 }
@@ -16,24 +18,24 @@ export declare class NotFoundResponse extends ErrorResponse {
     constructor(message: string);
 }
 export declare class ListErrorResponse {
-    data: null;
-    meta: null;
-    error: {
+    readonly data: null;
+    readonly meta: null;
+    readonly error: {
         code: string;
         message: string;
-        data?: any;
+        data: any;
+        stack: string | null;
     };
     constructor(params: ErrorResponseParams);
 }
 export declare class Response<T = any> {
-    data: T;
-    error: null;
+    readonly data: T;
+    readonly error: null;
     constructor(data: T);
 }
 export declare class ListResponse<T, M> {
-    data: Array<T>;
-    meta: M;
-    error: null;
+    readonly data: Array<T>;
+    readonly meta: M;
+    readonly error: null;
     constructor(data: Array<T>, meta?: M);
 }
-export {};

package/responses.js

@@ -12,7 +12,8 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 const defaultParams = {
   code: "",
   message: "",
-  data: null
+  data: null,
+  stack: null
 };
 
 class ErrorResponse {
@@ -20,10 +21,19 @@ class ErrorResponse {
     (0, _defineProperty2.default)(this, "data", void 0);
     (0, _defineProperty2.default)(this, "error", void 0);
     this.data = null;
+    const debug = process.env.DEBUG === "true"; // Ensure `stack` is either `string` or `null`.
+
+    let stack = defaultParams.stack;
+
+    if (debug && params.stack) {
+      stack = params.stack;
+    }
+
     this.error = {
       code: params.code || defaultParams.code,
       message: params.message || defaultParams.message,
-      data: params.data || defaultParams.data
+      data: params.data || defaultParams.data,
+      stack: stack
     };
   }
 
@@ -48,12 +58,21 @@ class ListErrorResponse {
     (0, _defineProperty2.default)(this, "data", void 0);
     (0, _defineProperty2.default)(this, "meta", void 0);
     (0, _defineProperty2.default)(this, "error", void 0);
-    this.data = null;
     this.meta = null;
+    this.data = null;
+    const debug = process.env.DEBUG === "true"; // Ensure `stack` is either `string` or `null`.
+
+    let stack = defaultParams.stack;
+
+    if (debug && params.stack) {
+      stack = params.stack;
+    }
+
     this.error = {
       code: params.code || defaultParams.code,
       message: params.message || defaultParams.message,
-      data: params.data || defaultParams.data
+      data: params.data || defaultParams.data,
+      stack: stack
     };
   }
 

package/responses.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["responses.ts"],"names":["defaultParams","code","message","data","stack","ErrorResponse","constructor","params","debug","process","env","DEBUG","error","NotFoundResponse","ListErrorResponse","meta","Response","ListResponse","Array","isArray"],"mappings":";;;;;;;;;;;AAOA,MAAMA,aAA4C,GAAG;AACjDC,EAAAA,IAAI,EAAE,EAD2C;AAEjDC,EAAAA,OAAO,EAAE,EAFwC;AAGjDC,EAAAA,IAAI,EAAE,IAH2C;AAIjDC,EAAAA,KAAK,EAAE;AAJ0C,CAArD;;AAOO,MAAMC,aAAN,CAAoB;AASvBC,EAAAA,WAAW,CAACC,MAAD,EAA8B;AAAA;AAAA;AACrC,SAAKJ,IAAL,GAAY,IAAZ;AAEA,UAAMK,KAAK,GAAGC,OAAO,CAACC,GAAR,CAAYC,KAAZ,KAAsB,MAApC,CAHqC,CAKrC;;AACA,QAAIP,KAAK,GAAGJ,aAAa,CAACI,KAA1B;;AACA,QAAII,KAAK,IAAID,MAAM,CAACH,KAApB,EAA2B;AACvBA,MAAAA,KAAK,GAAGG,MAAM,CAACH,KAAf;AACH;;AAED,SAAKQ,KAAL,GAAa;AACTX,MAAAA,IAAI,EAAEM,MAAM,CAACN,IAAP,IAAeD,aAAa,CAACC,IAD1B;AAETC,MAAAA,OAAO,EAAEK,MAAM,CAACL,OAAP,IAAkBF,aAAa,CAACE,OAFhC;AAGTC,MAAAA,IAAI,EAAEI,MAAM,CAACJ,IAAP,IAAeH,aAAa,CAACG,IAH1B;AAITC,MAAAA,KAAK,EAAEA;AAJE,KAAb;AAMH;;AA1BsB;;;;AA6BpB,MAAMS,gBAAN,SAA+BR,aAA/B,CAA6C;AAChDC,EAAAA,WAAW,CAACJ,OAAD,EAAkB;AACzB,UAAM;AACFD,MAAAA,IAAI,EAAE,WADJ;AAEFC,MAAAA;AAFE,KAAN;AAIH;;AAN+C;;;;AAS7C,MAAMY,iBAAN,CAAwB;AAU3BR,EAAAA,WAAW,CAACC,MAAD,EAA8B;AAAA;AAAA;AAAA;AACrC,SAAKQ,IAAL,GAAY,IAAZ;AACA,SAAKZ,IAAL,GAAY,IAAZ;AAEA,UAAMK,KAAK,GAAGC,OAAO,CAACC,GAAR,CAAYC,KAAZ,KAAsB,MAApC,CAJqC,CAMrC;;AACA,QAAIP,KAAK,GAAGJ,aAAa,CAACI,KAA1B;;AACA,QAAII,KAAK,IAAID,MAAM,CAACH,KAApB,EAA2B;AACvBA,MAAAA,KAAK,GAAGG,MAAM,CAACH,KAAf;AACH;;AAED,SAAKQ,KAAL,GAAa;AACTX,MAAAA,IAAI,EAAEM,MAAM,CAACN,IAAP,IAAeD,aAAa,CAACC,IAD1B;AAETC,MAAAA,OAAO,EAAEK,MAAM,CAACL,OAAP,IAAkBF,aAAa,CAACE,OAFhC;AAGTC,MAAAA,IAAI,EAAEI,MAAM,CAACJ,IAAP,IAAeH,aAAa,CAACG,IAH1B;AAITC,MAAAA,KAAK,EAAEA;AAJE,KAAb;AAMH;;AA5B0B;;;;AA+BxB,MAAMY,QAAN,CAAwB;AAI3BV,EAAAA,WAAW,CAACH,IAAD,EAAU;AAAA;AAAA;AACjB,SAAKA,IAAL,GAAYA,IAAZ;AACA,SAAKS,KAAL,GAAa,IAAb;AACH;;AAP0B;;;;AAUxB,MAAMK,YAAN,CAAyB;AAK5BX,EAAAA,WAAW,CAACH,IAAD,EAAiBY,IAAjB,EAA2B;AAAA;AAAA;AAAA;AAClC,SAAKZ,IAAL,GAAYe,KAAK,CAACC,OAAN,CAAchB,IAAd,IAAsBA,IAAtB,GAA6B,EAAzC;AACA,SAAKY,IAAL,GAAYA,IAAI,IAAK,EAArB;AACA,SAAKH,KAAL,GAAa,IAAb;AACH;;AAT2B","sourcesContent":["export interface ErrorResponseParams {\n    message: string;\n    code?: string;\n    data?: any;\n    stack?: string | null;\n}\n\nconst defaultParams: Required<ErrorResponseParams> = {\n    code: \"\",\n    message: \"\",\n    data: null,\n    stack: null\n};\n\nexport class ErrorResponse {\n    public readonly data: null;\n    public readonly error: {\n        code: string;\n        message: string;\n        data: any;\n        stack: string | null;\n    };\n\n    constructor(params: ErrorResponseParams) {\n        this.data = null;\n\n        const debug = process.env.DEBUG === \"true\";\n\n        // Ensure `stack` is either `string` or `null`.\n        let stack = defaultParams.stack;\n        if (debug && params.stack) {\n            stack = params.stack;\n        }\n\n        this.error = {\n            code: params.code || defaultParams.code,\n            message: params.message || defaultParams.message,\n            data: params.data || defaultParams.data,\n            stack: stack\n        };\n    }\n}\n\nexport class NotFoundResponse extends ErrorResponse {\n    constructor(message: string) {\n        super({\n            code: \"NOT_FOUND\",\n            message\n        });\n    }\n}\n\nexport class ListErrorResponse {\n    public readonly data: null;\n    public readonly meta: null;\n    public readonly error: {\n        code: string;\n        message: string;\n        data: any;\n        stack: string | null;\n    };\n\n    constructor(params: ErrorResponseParams) {\n        this.meta = null;\n        this.data = null;\n\n        const debug = process.env.DEBUG === \"true\";\n\n        // Ensure `stack` is either `string` or `null`.\n        let stack = defaultParams.stack;\n        if (debug && params.stack) {\n            stack = params.stack;\n        }\n\n        this.error = {\n            code: params.code || defaultParams.code,\n            message: params.message || defaultParams.message,\n            data: params.data || defaultParams.data,\n            stack: stack\n        };\n    }\n}\n\nexport class Response<T = any> {\n    public readonly data: T;\n    public readonly error: null;\n\n    constructor(data: T) {\n        this.data = data;\n        this.error = null;\n    }\n}\n\nexport class ListResponse<T, M> {\n    public readonly data: Array<T>;\n    public readonly meta: M;\n    public readonly error: null;\n\n    constructor(data: Array<T>, meta?: M) {\n        this.data = Array.isArray(data) ? data : [];\n        this.meta = meta || ({} as M);\n        this.error = null;\n    }\n}\n"]}

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}