1import fetch from "node-fetch";
 2
 3const projectId = <your project_id from PA>;
 4const apiKey = <your api key from PA>;
 5const buff = new Buffer(`${projectId}:${apiKey}`);
 6const basicAuth = buff.toString('base64')
 7
 8function sleep(ms) {
 9    return new Promise(resolve => setTimeout(resolve, ms));
10}
11
12async function getItems() {
13    // receive items from the original system or read from a pre-prepared file
14    return items;
15}
16
17function prepareData(items) {
18    // format items in accordance with API requirements
19    return formatedItems;
20}
21
22async function createItem(item) {
23    const url = `https://store.xsolla.com/api/v2/project/${projectId}/admin/items/virtual_items`;
24
25    return await fetch(url, {
26        method: "POST",
27        headers: {
28            Authorization: `Basic ${basicAuth}`,
29            "Content-Type": "application/json"
30        },
31        body: JSON.stringify(item),
32    });
33}
34
35async function isItemExisted(sku) {
36    const url = `https://store.xsolla.com/api/v2/project/${projectId}/admin/items/virtual_items/sku/${sku}`;
37    const response = await fetch(url, {
38        method: "GET",
39        headers: {
40            Authorization: `Basic ${basicAuth}`
41        }
42    });
43    return response.status !== 404;
44}
45
46async function createItems(items) {
47    let success = 0;
48    let alreadyCreated = 0;
49    for (let i = 0; i < items.length; i++) {
50        const item = items[i];
51        if (item['sku'] === undefined) {
52            console.log(`${i} Field "sku" not specified`);
53            continue;
54        }
55        const sku = item['sku'];
56        if (await isItemExisted(sku)) {
57            console.log(`${i} Item with sku "${sku}" already created`);
58            alreadyCreated++;
59            continue;
60        }
61        const response = await createItem(item);
62        if (response.status === 201) {
63            console.log(`${i} Item with sku "${sku}" successfully created`)
64            success++;
65        } else {
66            const jsonData = await response.json();
67            console.log(`${i} An error occurred while creating the items with sku "${sku}"`);
68            console.log(jsonData);
69        }
70        // add a delay so as not to run into rate limits
71        await sleep(500);
72    }
73    console.log(`${success} items out of ${items.length} created. ${alreadyCreated} items already existed`);
74}
75
76async function run() {
77  const items = await getItems();
78  const formattedItems = prepareData(items);
79  await createItems(formattedItems);
80}
81
82run(); 

  1import fetch from "node-fetch";
  2const projectId = <your project_id from PA>;
  3    const apiKey = <your api key from PA>;
  4        const buff = new Buffer(`${projectId}:${apiKey}`);
  5        const basicAuth = buff.toString('base64')
  6
  7        // ---------- Delay and backoff utilities ----------
  8        /** Pause for the specified number of milliseconds */
  9        function delay(ms) {
 10return new Promise((resolve) => setTimeout(resolve, ms));
 11}
 12        /**
 13        * A fetch wrapper that handles HTTP 429 responses:
 14        * - pure exponential backoff with jitter (ignores Retry-After);
 15        * - limited number of retry attempts.
 16        */
 17        async function fetchWithRateLimit(
 18        url,
 19        options = { },
 20        {
 21            maxAttempts = 4, // 1 initial attempt + 3 retries (balanced approach)
 22            baseDelayMs = 1000, // 1 second base delay (15x the 67ms interval for 15 RPS)
 23            factor = 1.5, // gentler backoff multiplier (1s → 1.5s → 2.25s → 3.4s)
 24            maxDelayMs = 4000, // 4 seconds max delay (prevents excessive waiting)
 25            jitterMs = 300 // 300ms random jitter (spreads retries without long delays)
 26        } = { }
 27        ) {
 28            let attempt = 0;
 29        while (true) {
 30            attempt += 1;
 31        const res = await fetch(url, options);
 32        if (res.status !== 429) return res;
 33        // 429: calculate pause (exponential backoff + jitter)
 34        const backoff = Math.min(
 35        Math.floor(baseDelayMs * Math.pow(factor, attempt - 1)),
 36        maxDelayMs
 37        );
 38        const jitter = Math.floor(Math.random() * (jitterMs + 1)); // 0..jitterMs
 39        const waitMs = backoff + jitter;
 40if (attempt >= maxAttempts) {
 41// retry limit reached — return the last response
 42return res;
 43}
 44        await delay(waitMs);
 45}
 46}
 47        // ---------- Your data and preparation ----------
 48        /**
 49        * Retrieve items from your system (DB/file/etc.).
 50        * Must return an array of objects with sku and other data fields.
 51        */
 52        async function getItems() {
 53// receive items from the original system or read from a pre-prepared file
 54return items;
 55}
 56        /** Convert the data to match the "Create Virtual Item" API format */
 57        function prepareData(items) {
 58// format items in accordance with API requirements
 59const formattedItems = items; // For now, assume items are already in correct format
 60        return formattedItems;
 61}
 62        // ---------- Xsolla API calls ----------
 63        /** Check whether an item with this SKU exists: 200 — exists, 404 — doesn't exist */
 64        async function checkItemExist(sku) {
 65const url = `https://store.xsolla.com/api/v2/project/${projectId}/admin/items/virtual_items/sku/${encodeURIComponent(
 66            sku
 67        )}`;
 68        const response = await fetchWithRateLimit(url, {
 69            method: "GET",
 70        headers: {
 71            Authorization: `Basic ${basicAuth}`
 72}
 73});
 74        if (response.status === 200) return true;
 75        if (response.status === 404) return false;
 76// Treat all other statuses as errors for clarity
 77const body = await response.text().catch(() => "");
 78        throw new Error(
 79        `checkItemExist failed: ${response.status} ${response.statusText} ${body}`
 80        );
 81}
 82        /** Create a virtual item with 429/backoff handling */
 83        async function createItem(item) {
 84const url = `https://store.xsolla.com/api/v2/project/${projectId}/admin/items/virtual_items`;
 85        return await fetchWithRateLimit(url, {
 86            method: "POST",
 87        headers: {
 88            Authorization: `Basic ${basicAuth}`,
 89        "Content-Type": "application/json"
 90},
 91        body: JSON.stringify(item)
 92});
 93}
 94        // ---------- Main procedure ----------
 95        async function createItems(items) {
 96            let success = 0;
 97        let alreadyCreated = 0;
 98        for (let i = 0; i < items.length; i++) {
 99const item = items[i];
100        if (item == null) {
101            console.log(`${i} Error: Item at index ${i} is null or undefined`);
102        continue;
103}
104        if (item.sku == null || item.sku === undefined || item.sku === '') {
105            console.log(`${i} Error: Item at index ${i} is missing required 'sku' field`);
106        continue;
107}
108        const sku = String(item.sku);
109        // Idempotency: skip creation if the item already exists
110        let exists;
111        try {
112            exists = await checkItemExist(sku);
113} catch (e) {
114            console.log(`${i} Failed to check SKU "${sku}": ${e.message}`);
115// optionally: continue;
116}
117        if (exists === true) {
118            console.log(`${i} Item with sku "${sku}" already created`);
119        alreadyCreated++;
120        continue;
121}
122        const response = await createItem(item);
123        if (response.status === 201) {
124            console.log(`${i} Item with sku "${sku}" successfully created`);
125        success++;
126} else if (response.status === 429) {
127const text = await response.text().catch(() => "");
128        console.log(
129        `${i} Rate limit when creating sku "${sku}" after retries: ${response.status} ${response.statusText}`
130        );
131        if (text) console.log(text);
132} else {
133const text = await response.text().catch(() => "");
134        console.log(
135        `${i} An error occurred while creating the item with sku "${sku}": ${response.status} ${response.statusText}`
136        );
137        if (text) console.log(text);
138}
139// No fixed delay needed — backoff is handled inside fetchWithRateLimit on 429
140}
141        console.log(
142        `${success} items out of ${items.length} created. ${alreadyCreated} items already existed`
143        );
144}
145        async function run() {
146const items = await getItems();
147        const formattedItems = prepareData(items);
148        await createItems(formattedItems);
149}
150run().catch((e) => {
151            console.error("Unhandled script error:", e);
152        process.exitCode = 1;
153});