rozod 1.0.0

package/lib/index.js

@@ -0,0 +1,293 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchApiPagesGenerator = exports.fetchApiPages = exports.fetchApiSplit = exports.fetchApi = void 0;
+var zod_1 = require("zod");
+function extractDefaultValues(endpoint) {
+    var defaultValues = {};
+    var paramKeys = Object.keys(endpoint.parameters);
+    for (var _i = 0, paramKeys_1 = paramKeys; _i < paramKeys_1.length; _i++) {
+        var key = paramKeys_1[_i];
+        var schema = endpoint.parameters[key];
+        if (schema instanceof zod_1.z.ZodDefault) {
+            defaultValues[key] = schema._def.defaultValue();
+        }
+    }
+    return defaultValues;
+}
+/**
+ * Fetches the data from the given endpoint and returns it.
+ *
+ * @param endpoint The endpoint to fetch from.
+ * @param params The parameters to pass to the endpoint.
+ * @param requestOptions Any additional options to pass to fetch.
+ * @returns The response from the endpoint.
+ */
+function fetchApi(endpoint, params, requestOptions) {
+    if (requestOptions === void 0) { requestOptions = { mode: 'cors', credentials: 'include' }; }
+    return __awaiter(this, void 0, void 0, function () {
+        var method, path, requestFormat, defaultValues, extendedParams, body, query, response, error, data, validationResult;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    method = endpoint.method, path = endpoint.path, requestFormat = endpoint.requestFormat;
+                    defaultValues = extractDefaultValues(endpoint);
+                    extendedParams = __assign(__assign({}, defaultValues), params);
+                    query = '';
+                    if (method !== 'get' && requestFormat === 'json') {
+                        body = JSON.stringify(extendedParams);
+                    }
+                    else {
+                        query = '?' + new URLSearchParams(extendedParams).toString();
+                    }
+                    return [4 /*yield*/, fetch(endpoint.baseUrl + path + query, __assign({ method: method, body: body }, requestOptions))];
+                case 1:
+                    response = _a.sent();
+                    error = endpoint.errors.find(function (_a) {
+                        var status = _a.status;
+                        return status === response.status;
+                    });
+                    if (error) {
+                        throw new Error(error.description);
+                    }
+                    return [4 /*yield*/, response.json()];
+                case 2:
+                    data = _a.sent();
+                    validationResult = endpoint.response.safeParse(data);
+                    if (!validationResult.success) {
+                        throw new Error('Invalid response data');
+                    }
+                    return [2 /*return*/, validationResult.data];
+            }
+        });
+    });
+}
+exports.fetchApi = fetchApi;
+/**
+ * Fetches the data from the given endpoint, but splits the request into multiple requests if the specified parameter is larger than max specified.
+ *
+ * @param endpoint The endpoint to fetch from.
+ * @param params The parameters to pass to the endpoint.
+ * @param max The maximum number of items to pass to the endpoint.
+ * @param transform A function that accepts the endpoint response and transforms it into the desired type.
+ * @param requestOptions Any additional options to pass to fetch.
+ * @returns The transformed response from the endpoint.
+ * @example
+ * ```ts
+ * const data = await fetchApiSplit(getV1gamesicons, { universeIds: [1, 2, 3, 4, 5] }, { universeIds: 100 }, (response) => response.data);
+ * console.log(data); // [[{ "targetId": 0, "state": "Completed", "imageUrl": "..." }], ...]
+ * ```
+ */
+function fetchApiSplit(endpoint, params, max, transform, requestOptions) {
+    if (transform === void 0) { transform = function (response) { return response; }; }
+    return __awaiter(this, void 0, void 0, function () {
+        var fetchTransformed, splitParams, key, maxItems, items, i, itemsSubset, newParams, allResults, _i, splitParams_1, splitParam, transformedResponse;
+        var _a;
+        var _this = this;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    fetchTransformed = function (transformparams) { return __awaiter(_this, void 0, void 0, function () {
+                        var response;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, fetchApi(endpoint, transformparams, requestOptions)];
+                                case 1:
+                                    response = _a.sent();
+                                    return [2 /*return*/, transform ? transform(response) : response];
+                            }
+                        });
+                    }); };
+                    if (!!max) return [3 /*break*/, 2];
+                    return [4 /*yield*/, fetchTransformed(params)];
+                case 1: return [2 /*return*/, [_b.sent()]];
+                case 2:
+                    splitParams = [];
+                    for (key in max) {
+                        if (!{}.hasOwnProperty.call(max, key) || !{}.hasOwnProperty.call(params, key)) {
+                            continue;
+                        }
+                        maxItems = max[key];
+                        items = params[key];
+                        if (Array.isArray(items)) {
+                            // eslint-disable-next-line max-depth
+                            for (i = 0; i < items.length; i = i + (maxItems || 1)) {
+                                itemsSubset = items.slice(i, i + (maxItems || 1));
+                                newParams = __assign(__assign({}, params), (_a = {}, _a[key] = itemsSubset, _a));
+                                splitParams.push(newParams);
+                            }
+                        }
+                    }
+                    if (!(splitParams.length === 0)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, fetchTransformed(params)];
+                case 3: return [2 /*return*/, [_b.sent()]];
+                case 4:
+                    allResults = [];
+                    _i = 0, splitParams_1 = splitParams;
+                    _b.label = 5;
+                case 5:
+                    if (!(_i < splitParams_1.length)) return [3 /*break*/, 8];
+                    splitParam = splitParams_1[_i];
+                    return [4 /*yield*/, fetchTransformed(splitParam)];
+                case 6:
+                    transformedResponse = _b.sent();
+                    allResults.push(transformedResponse);
+                    _b.label = 7;
+                case 7:
+                    _i++;
+                    return [3 /*break*/, 5];
+                case 8: return [2 /*return*/, allResults];
+            }
+        });
+    });
+}
+exports.fetchApiSplit = fetchApiSplit;
+/**
+ * Fetches all pages of results for the given endpoint and parameters.
+ *
+ * @param endpoint The endpoint to fetch.
+ * @param initialParams The initial parameters to use for the endpoint.
+ * @param requestOptions The options to use when making requests.
+ * @param limit The maximum number of pages to fetch.
+ * @returns An array of all results.
+ */
+function fetchApiPages(endpoint, initialParams, requestOptions, limit) {
+    if (limit === void 0) { limit = 1000; }
+    return __awaiter(this, void 0, void 0, function () {
+        var cursor, allResults, paramsWithCursor, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    allResults = [];
+                    _a.label = 1;
+                case 1:
+                    if (!true) return [3 /*break*/, 3];
+                    paramsWithCursor = __assign(__assign({}, initialParams), { cursor: cursor });
+                    return [4 /*yield*/, fetchApi(endpoint, paramsWithCursor, requestOptions)];
+                case 2:
+                    response = _a.sent();
+                    allResults.push(response);
+                    if ('nextPageCursor' in response) {
+                        cursor = response.nextPageCursor;
+                    }
+                    else {
+                        return [3 /*break*/, 3];
+                    }
+                    if (allResults.length >= limit) {
+                        return [3 /*break*/, 3];
+                    }
+                    return [3 /*break*/, 1];
+                case 3: return [2 /*return*/, allResults];
+            }
+        });
+    });
+}
+exports.fetchApiPages = fetchApiPages;
+/**
+ * Fetches all pages of results for the given endpoint and parameters.
+ * This is a generator function that yields each page as it is fetched.
+ *
+ * @param endpoint The endpoint to fetch.
+ * @param initialParams The initial parameters to use for the endpoint.
+ * @param requestOptions The options to use when making requests.
+ * @param limit The maximum number of pages to fetch.
+ * @returns An array of all results.
+ * @yields The next page of results.
+ * @example
+ * ```ts
+ * const pages = fetchApiPagesGenerator(getV1badgesicons, { badgeIds: [1, 2, 3] });
+ * for await (const page of pages) {
+ *    console.log(page.data);
+ * }
+ * ```
+ */
+function fetchApiPagesGenerator(endpoint, initialParams, requestOptions, limit) {
+    if (limit === void 0) { limit = 1000; }
+    return __asyncGenerator(this, arguments, function fetchApiPagesGenerator_1() {
+        var cursor, paramsWithCursor, response;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!true) return [3 /*break*/, 4];
+                    paramsWithCursor = __assign(__assign({}, initialParams), { cursor: cursor });
+                    return [4 /*yield*/, __await(fetchApi(endpoint, paramsWithCursor, requestOptions))];
+                case 1:
+                    response = _a.sent();
+                    return [4 /*yield*/, __await(response)];
+                case 2: return [4 /*yield*/, _a.sent()];
+                case 3:
+                    _a.sent();
+                    if ('nextPageCursor' in response) {
+                        cursor = response.nextPageCursor;
+                    }
+                    else {
+                        return [3 /*break*/, 4];
+                    }
+                    if (limit-- <= 0) {
+                        return [3 /*break*/, 4];
+                    }
+                    return [3 /*break*/, 0];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.fetchApiPagesGenerator = fetchApiPagesGenerator;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "rozod",
+  "version": "1.0.0",
+  "description": "Wrapper for Roblox API using Zod and custom API Client using fetch",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "test": "jest --config jestconfig.json",
+    "build": "tsc",
+    "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
+    "lint": "tslint -p tsconfig.json",
+    "prepare" : "npm run build",
+    "prepublishOnly" : "npm test && npm run lint",
+    "preversion" : "npm run lint",
+    "version" : "npm run format && git add -A src"
+  },
+  "author": "alexop1000",
+  "license": "ISC",
+  "dependencies": {
+    "zod": "^3.21.4"
+  },
+  "devDependencies": {
+    "@apidevtools/swagger-parser": "^10.1.0",
+    "@types/jest": "^29.5.1",
+    "@zodios/plugins": "^10.6.0",
+    "jest": "^29.5.0",
+    "openapi-zod-client": "^1.6.3",
+    "prettier": "^2.8.8",
+    "swagger2openapi": "^7.0.8",
+    "ts-jest": "^29.1.0",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^5.0.4"
+  },
+  "keywords": [],
+  "files": [
+    "lib/**/*"
+  ]
+}

package/readme.md

@@ -0,0 +1,99 @@
+# RoZod
+
+RoZod is a TypeScript package designed to simplify fetching data from the Roblox API. It provides a set of utility functions that automatically validate request and response data using the Zod validation library.
+
+## Features
+
+- Type-safe API requests and responses
+- Automatic validation of request and response data
+- Helper functions for paginated requests and splitting requests
+
+## Installation
+
+To install the package, run the following command:
+
+```bash
+npm install rozod
+```
+
+## Usage
+First, import the necessary functions and an example endpoint from the RoZod package:
+
+```ts
+import { fetchApi, fetchApiSplit, fetchApiPages, fetchApiPagesGenerator } from 'rozod';
+import { getV1tradesTradeStatusType } from 'rozod/endpoints/tradesv1';
+```
+
+### Simple API Request
+
+To make a simple API request, use the `fetchApi` function, and any endpoint from our exports:
+
+```ts
+const response = await fetchApi(getV1tradesTradeStatusType, { tradeStatusType: 1 });
+console.log(response);
+```
+
+### Split API Request
+To split a request into multiple requests based on specified parameters, use the `fetchApiSplit` function:
+
+```ts
+const data = await fetchApiSplit(getV1gamesicons, { universeIds: [1534453623, 65241, ...] }, { universeIds: 100 });
+console.log(data);
+```
+
+### Fetching All Pages
+To fetch all pages of a paginated endpoint, use the `fetchApiPages` function:
+
+```ts
+const allPages = await fetchApiPages(getV2groupsGroupIdgames, { groupId: 11479637 });
+console.log(allPages);
+```
+### Fetching Pages with a Generator
+To fetch pages one at a time using an async generator, use the `fetchApiPagesGenerator` function:
+
+```ts
+const allPages = await fetchApiPages(getV2groupsGroupIdgames, { groupId: 11479637 });
+console.log(allPages);
+```
+
+Custom Endpoints
+To create a custom endpoint, define an EndpointSchema object and export it. Here's an example of an endpoint from tradesv1.ts:
+```ts
+import { z } from 'zod';
+
+export const getV1tradesTradeStatusType = {
+  method: 'get' as const,
+  path: '/v1/trades/:tradeStatusType',
+  baseUrl: 'https://trades.roblox.com',
+  requestFormat: 'json' as const,
+  parameters: {
+    tradeStatusType: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]),
+    limit: z
+      .union([z.literal(10), z.literal(25), z.literal(50), z.literal(100)])
+      .optional()
+      .default(10),
+    cursor: z.string().optional(),
+    sortOrder: z.enum(['Asc', 'Desc']).optional().default('Asc'),
+  },
+  response: ...,
+  errors: [
+    {
+      status: 400,
+      description: `1: Invalid trade status type.`,
+      schema: z.void(),
+    },
+    {
+      status: 401,
+      description: `0: Authorization has been denied for this request.`,
+      schema: z.void(),
+    },
+  ],
+};
+```
+Replace the response with your own Zod schema to validate the response data.
+
+## Support
+If you encounter any issues or have questions, feel free to open an issue on the GitHub repository. We'll do our best to assist you.
+
+## Disclaimer
+RoZod is not affiliated with, maintained, authorized, endorsed, or sponsored by Roblox Corporation or any of its affiliates.