@jd-data-limited/easy-fm 4.0.16 → 4.1.1

package/src/records/field.ts

@@ -2,21 +2,34 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import * as http from "http";
-import {ContainerBufferResult, DownloadModes, FieldMetaData, RecordTypes} from "../types.js";
-import {ApiFieldDisplayTypes, ApiFieldMetadata, ApiFieldResultTypes, ApiFieldTypes} from "../models/apiResults.js";
-import {LayoutBase} from "../layouts/layoutBase.js";
-import {Moment} from "moment";
+import {RecordTypes} from '../types.js'
+import {ApiFieldDisplayTypes, type ApiFieldMetadata, ApiFieldResultTypes, ApiFieldTypes} from '../models/apiResults.js'
+import {type LayoutBase} from '../layouts/layoutBase.js'
+import {type Moment} from 'moment'
+import {FMError} from "../FMError.js";
 
 export type FieldValue = string | number | Moment | Container
 export type Container = null
 
-export type Parentable = {layout: LayoutBase, type: RecordTypes, endpoint: string}
+export interface Parentable {
+    layout: LayoutBase
+    type: RecordTypes
+    endpoint: string
+    portal?: { name: string }
+}
+
+/**
+ * A class representing a field in a record.
+ *
+ * @template T - The type of the field value.
+ */
 export class Field<T extends FieldValue> {
-    parent: Parentable;
-    id: string;
-    protected _value: T;
-    edited: boolean;
+    parent: Parentable
+    id: string
+    protected _value: T | null
+    edited: boolean
+
+    static firstContainerDownload: Promise<any> | null = null
 
     constructor(record: Parentable, id: string, contents: T) {
         this.parent = record
@@ -25,11 +38,14 @@ export class Field<T extends FieldValue> {
         this.edited = false
     }
 
-    set(content: T) {
-        if (this.metadata.result === "container") throw "Cannot set container value using set(). Use upload() instead."
-        // @ts-ignore
-        if (!content) this._value = ""
-        // @ts-ignore
+    /**
+     * Sets the value of the field.
+     *
+     * @param {T | null} content - The new content value to be set. Can be either the type T or null.
+     * @throws {Error} Cannot set container value using set(). Use upload() instead, if the result is a 'container'.
+     */
+    set(content: T | null) {
+        if (this.metadata.result === 'container') throw new Error('Cannot set container value using set(). Use upload() instead.')
         else this._value = content
         this.edited = true
     }
@@ -51,30 +67,30 @@ export class Field<T extends FieldValue> {
                 numeric: false,
                 timeOfDay: false,
                 repetitions: 1,
-                valueList: ""
+                valueList: ''
             }
         }
-        if (this.parent.type === RecordTypes.PORTAL) {
-            // @ts-ignore
-            return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || "portal not attached"].find(i => i.name === this.id) as FieldMetaData || {
-                name: this.id.toString(),
-                type: 'normal',
-                displayType: 'editText',
-                result: 'text',
-                global: false,
-                autoEnter: true,
-                fourDigitYear: false,
-                maxRepeat: 1,
-                maxCharacters: 0,
-                notEmpty: false,
-                numeric: false,
-                timeOfDay: false,
-                repetitionStart: 1,
-                repetitionEnd: 1
-            } as FieldMetaData
+        if (this.parent.type === RecordTypes.PORTAL && this.parent.portal) {
+            return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || 'portal not attached'].find(i => i.name === this.id) ??
+                {
+                    name: this.id.toString(),
+                    type: ApiFieldTypes.NORMAL,
+                    displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                    result: ApiFieldResultTypes.TEXT,
+                    global: false,
+                    autoEnter: true,
+                    fourDigitYear: false,
+                    maxRepeat: 1,
+                    maxCharacters: 0,
+                    notEmpty: false,
+                    numeric: false,
+                    timeOfDay: false,
+                    repetitions: 1,
+                    valueList: ''
+                }
         }
         else {
-            return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) || {
+            return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) ?? {
                 name: this.id.toString(),
                 type: ApiFieldTypes.NORMAL,
                 displayType: ApiFieldDisplayTypes.EDIT_TEXT,
@@ -88,12 +104,12 @@ export class Field<T extends FieldValue> {
                 numeric: false,
                 timeOfDay: false,
                 repetitions: 1,
-                valueList: ""
+                valueList: ''
             }
         }
     }
 
-    get value(): T {
+    get value(): T | null {
         // if (this.metadata.result === "container") throw "Use await field.stream() to get the contents of a container field, instead of field.value"
         return this._value
     }
@@ -103,65 +119,127 @@ export class Field<T extends FieldValue> {
     }
 
     get string(): string {
-        if (typeof this._value === "string") {
+        if (typeof this._value === 'string') {
             return this._value
         }
-        throw "Field value is not a string"
+        throw new Error('Field value is not a string')
     }
 
-    get date(): Date {
-        if (this._value instanceof Date) {
-            return this._value
+    /**
+     * Uploads a file to the container field.
+     *
+     * @param {Buffer} file - The file content as a buffer.
+     *
+     * @throws {Error} - Cannot upload a file to the field if it's not a container field.
+     * @throws {Error} - Upload failed with HTTP error.
+     *
+     * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
+     */
+    async upload(file: File): Promise<void> {
+        if (this.metadata.result !== 'container') {
+            throw new Error('Cannot upload a file to the field; ' + this.id + ' (not a container field)')
+        }
+        const form = new FormData()
+        form.append('upload', file)
+
+        console.log(`ENDPOINT: ${this.parent.endpoint}/containers/${this.id}/1`)
+        const res = await this.parent.layout.database._apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
+            method: 'POST',
+            headers: {
+                // Authorization: 'Bearer ' + this.parent.layout.database.token,
+                // 'Content-Type': 'multipart/form-data'
+            },
+            body: form
+        })
+        if (!res.ok) {
+            console.log("RESULT:", await res.text())
+            throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`)
+        }
+        const data: { messages: Array<{ code: string }> } = await res.json() as any
+        if (data.messages[0].code === "0") return
+        else {
+            console.log(data)
+            throw new FMError(data.messages[0].code, res.status, res)
         }
-        throw "Field value is not a date"
     }
 
-    get number(): number {
-        if (typeof this._value === "number") {
-            return this._value
+    @containerDownloadFunction
+    async #streamAsync() {
+        let req = await this.parent.layout.database._apiRequestRaw(this.string, {useCookieJar: true})
+        if (!req.ok || !req.body) {
+            throw new Error(`HTTP Error: ${req.status} (${req.statusText})`)
         }
-        throw "Field value is not a number"
+        return req.body
     }
 
-    async upload(buffer: Buffer, filename: string, mime: string): Promise<void> {
-        let trace = new Error()
-        if (this.metadata.result !== "container") throw "Cannot upload a file to the field; " + this.id + " (not a container field)"
-        let form = new FormData()
-        form.append("upload", new File([buffer], filename, {type: mime}))
+    stream() {
+        return this.#streamAsync()
+    }
 
-        let res = await this.parent.layout.database.apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
-            method: "POST",
-            // @ts-ignore
-            body: form
-        })
-        if (!res.ok) throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`)
+    @containerDownloadFunction
+    async arrayBuffer() {
+        console.log(this.string)
+        const req = await this.parent.layout.database._apiRequestRaw(this.string, {useCookieJar: true})
+        if (!req.ok) throw new Error(`HTTP Error: ${req.status} (${req.statusText})`)
+        console.log(req)
+        return await req.arrayBuffer()
     }
+}
 
-    download(mode: DownloadModes.Stream): Promise<http.IncomingMessage>
-    download(mode: DownloadModes.Buffer): Promise<ContainerBufferResult>
-    async download(mode: DownloadModes = DownloadModes.Stream): Promise<http.IncomingMessage | ContainerBufferResult> {
-        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER) throw new Error("Cannot perform download() on a non-container field")
+function containerDownloadFunction<T extends FieldValue, R = unknown>(originalMethod: (...p: any[]) => Promise<R>, context: ClassMethodDecoratorContext<Field<T>>) {
+    async function replacementMethod(this: Field<T>, ...args: any[]) {
+        return ContainerDownloadExecutor.processTask(() => originalMethod.call(this, ...args))
+    }
 
-        let stream = await this.parent.layout.database.streamURL(this.string)
-        if (mode === DownloadModes.Stream) {
-            return stream
+    return replacementMethod
+}
+
+class ContainerDownloadExecutorClass {
+    hasDownloadedFirstContainer: 0 | 1 | 2 = 0
+    waitingFuncs: {
+        func: (() => any),
+        done: ((...args: any[]) => any),
+        err: ((e: Error) => any)
+    }[] = []
+
+    constructor() {}
+
+    async processTask<T extends () => Promise<any>>(task: T) {
+        let isFirstTask = this.hasDownloadedFirstContainer === 0
+        if (isFirstTask) {
+            this.hasDownloadedFirstContainer = 1
+            let res
+            try {
+                res = await task()
+            } catch(e) {
+                this.hasDownloadedFirstContainer = 0
+                let nextTask = this.waitingFuncs.splice(0, 1)[0]
+                if (nextTask) {
+                    this.processTask(nextTask.func)
+                        .then(res => nextTask.done(res))
+                        .catch(e => nextTask.err(e))
+                }
+                throw e
+            }
+            this.hasDownloadedFirstContainer = 2
+            for (let task of this.waitingFuncs) {
+                task.func()
+                    .then((res: any) => task.done(res))
+                    .catch((e: any) => task.err(e))
+            }
+            return res
         }
-
-        let body: Uint8Array[] = []
-        return new Promise((resolve, reject) => {
-            stream.on("data", chunk => {
-                body.push(chunk)
-            })
-            stream.on("error", (e) => {
-                reject(e)
-            })
-            stream.on("end", () => {
-                resolve({
-                    buffer: Buffer.concat(body),
-                    mime: stream.headers["content-type"],
-                    request: stream
-                } as ContainerBufferResult)
+        else if (this.hasDownloadedFirstContainer === 1) {
+            return new Promise((resolve, reject) => {
+                this.waitingFuncs.push({
+                    func: task,
+                    done: resolve,
+                    err: reject
+                })
             })
-        })
+        }
+        else return await task()
     }
-}
+}
+
+const ContainerDownloadExecutor = new ContainerDownloadExecutorClass()

package/src/records/getOperations/recordGetOperation.d.ts

@@ -1,54 +1,74 @@
-import { LayoutInterface } from "../../layouts/layoutInterface.js";
-import { PickPortals, ScriptRequestData } from "../../types.js";
-import { LayoutBase } from "../../layouts/layoutBase.js";
-import { LayoutRecord } from "../layoutRecord.js";
-import { Query } from "../../utils/query.js";
-export type SortOrder = "ascend" | "descend";
-export type FindRequestRaw = {
-    [key: string]: string;
-};
-export type FindRequest = {
-    [key: string]: Query;
-};
-export type PortalRequest = {
+import { type LayoutInterface } from '../../layouts/layoutInterface.js';
+import { type PickPortals, type ScriptRequestData } from '../../types.js';
+import { type LayoutBase } from '../../layouts/layoutBase.js';
+import { LayoutRecord } from '../layoutRecord.js';
+import { type Query } from '../../utils/query.js';
+export type SortOrder = 'ascend' | 'descend';
+export type FindRequestRaw = Record<string, string>;
+export type FindRequest = Record<string, Query>;
+export interface PortalRequest {
     name: string;
-};
+}
 type PortalData<T extends LayoutInterface> = {
-    [key in keyof T["portals"]]: {
+    [key in keyof T['portals']]: {
         limit: number;
         offset: number;
     };
 };
-export type GetOperationOptions<T extends LayoutInterface> = {
+export interface GetOperationOptions<T extends LayoutInterface> {
     portals: Partial<PortalData<T>>;
     limit?: number;
     offset?: number;
-};
+}
 export declare class RecordGetOperation<T extends LayoutInterface, OPTIONS extends GetOperationOptions<T>> {
     protected layout: LayoutBase;
     protected limit: number;
     protected scriptData: ScriptRequestData;
-    protected sortData: {
+    protected sortData: Array<{
         fieldName: string;
         sortOrder: SortOrder;
-    }[];
+    }>;
     protected portals: Partial<PortalData<T>>;
     protected offset: number;
-    protected queries: {
+    protected queries: Array<{
         req: FindRequestRaw;
         omit: boolean;
-    }[];
+    }>;
     constructor(layout: LayoutBase, options: OPTIONS);
     get isFindRequest(): boolean;
     private formatQueries;
-    protected generateParamsBody(offset: number, limit: number): {
-        [key: string]: any;
-    };
+    protected generateParamsBody(offset: number, limit: number): Record<string, any>;
     protected generateParamsURL(offset: number, limit: number): URLSearchParams;
+    /**
+     * Configures any FileMaker scripts to be run as a part of the request
+     *
+     * @param {ScriptRequestData} scripts - The script request data to set.
+     * @return {this} - The current instance of the class.
+     */
     scripts(scripts: ScriptRequestData): this;
+    /**
+     * Sorts the data based on the given field name and sort order.
+     *
+     * @param {string} fieldName - The name of the field by which the data should be sorted.
+     * @param {SortOrder} sortOrder - The sort order to be applied (either "asc" for ascending or "desc" for descending).
+     *
+     * @return {this} - Returns the current instance of the object.
+     */
     sort(fieldName: string, sortOrder: SortOrder): this;
     private parseFindRequest;
+    /**
+     * Adds a new request/query to the list of queries.
+     *
+     * @param {FindRequest} query - The find request to be added.
+     * @param {boolean} [omit=false] - Flag to indicate if the find request should be omitted.
+     * @return {Object} - The current object instance.
+     */
     addRequest(query: FindRequest, omit?: boolean): this;
+    /**
+     * Perform a fetch operation.
+     *
+     * @returns {Promise} A promise that resolves with the result of the fetch operation.
+     */
     fetch(): Promise<LayoutRecord<PickPortals<T, keyof OPTIONS["portals"]>>[]>;
     private performFind;
     [Symbol.asyncIterator](): {

package/src/records/getOperations/recordGetOperation.js

@@ -1,9 +1,9 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { LayoutRecord } from "../layoutRecord.js";
-import { FMError } from "../../FMError.js";
-import { FindRequestSymbol } from "../../utils/query.js";
+import { LayoutRecord } from '../layoutRecord.js';
+import { FMError } from '../../FMError.js';
+import { FindRequestSymbol } from '../../utils/query.js';
 export class RecordGetOperation {
     layout;
     limit = 100;
@@ -16,16 +16,16 @@ export class RecordGetOperation {
         this.layout = layout;
         this.sortData = [];
         this.portals = options.portals;
-        this.offset = options.offset || 1; // Offset refers to the starting record. offset 1 is the same as no offset.
-        this.limit = options.limit || 100;
+        this.offset = options.offset ?? 1; // Offset refers to the starting record. offset 1 is the same as no offset.
+        this.limit = options.limit ?? 100;
     }
     get isFindRequest() {
         return this.queries.length !== 0;
     }
     formatQueries() {
-        let test = this.queries.map(query => {
-            let out = {};
-            for (let key of Object.keys(query.req)) {
+        const test = this.queries.map(query => {
+            const out = {};
+            for (const key of Object.keys(query.req)) {
                 if (query.req[key])
                     out[key] = query.req[key];
                 else {
@@ -33,7 +33,7 @@ export class RecordGetOperation {
                 }
             }
             if (query.omit)
-                out.omit = "true";
+                out.omit = 'true';
             return out;
         });
         return test;
@@ -47,22 +47,22 @@ export class RecordGetOperation {
         if (this.sortData.length !== 0)
             params.sort = this.sortData;
         if (this.scriptData.after)
-            params["script"] = this.scriptData.after.name;
+            params.script = this.scriptData.after.name;
         if (this.scriptData.after?.parameter)
-            params["script.param"] = this.scriptData.after.parameter;
+            params['script.param'] = this.scriptData.after.parameter;
         if (this.scriptData.presort)
-            params["script.presort"] = this.scriptData.presort.name;
+            params['script.presort'] = this.scriptData.presort.name;
         if (this.scriptData.presort?.parameter)
-            params["script.presort.param"] = this.scriptData.presort.parameter;
+            params['script.presort.param'] = this.scriptData.presort.parameter;
         if (this.scriptData.prerequest)
-            params["script.prerequest"] = this.scriptData.prerequest.name;
+            params['script.prerequest'] = this.scriptData.prerequest.name;
         if (this.scriptData.prerequest?.parameter)
-            params["script.prerequest.param"] = this.scriptData.prerequest.parameter;
+            params['script.prerequest.param'] = this.scriptData.prerequest.parameter;
         if (this.queries.length !== 0)
-            params["query"] = this.formatQueries();
-        let portals = Object.keys(this.portals);
-        params["portal"] = portals;
-        for (let portal of portals) {
+            params.query = this.formatQueries();
+        const portals = Object.keys(this.portals);
+        params.portal = portals;
+        for (const portal of portals) {
             params[`offset.${portal.toString()}`] = this.portals[portal]?.offset;
             params[`limit.${portal.toString()}`] = this.portals[portal]?.limit;
         }
@@ -72,80 +72,107 @@ export class RecordGetOperation {
         const params = new URLSearchParams({
             _limit: limit.toString(),
             _offset: offset.toString(),
-            dateformats: "2" // Ensure dates are received in ISO8601 format
+            dateformats: '2' // Ensure dates are received in ISO8601 format
         });
         if (this.sortData.length !== 0)
-            params.set("_sort", JSON.stringify(this.sortData));
+            params.set('_sort', JSON.stringify(this.sortData));
         if (this.scriptData.after)
-            params.set("script", this.scriptData.after.name);
+            params.set('script', this.scriptData.after.name);
         if (this.scriptData.after?.parameter)
-            params.set("script.param", this.scriptData.after.parameter);
+            params.set('script.param', this.scriptData.after.parameter);
         if (this.scriptData.presort)
-            params.set("script.presort", this.scriptData.presort.name);
+            params.set('script.presort', this.scriptData.presort.name);
         if (this.scriptData.presort?.parameter)
-            params.set("script.presort.param", this.scriptData.presort.parameter);
+            params.set('script.presort.param', this.scriptData.presort.parameter);
         if (this.scriptData.prerequest)
-            params.set("script.prerequest", this.scriptData.prerequest.name);
+            params.set('script.prerequest', this.scriptData.prerequest.name);
         if (this.scriptData.prerequest?.parameter)
-            params.set("script.prerequest.param", this.scriptData.prerequest.parameter);
-        let portals = Object.keys(this.portals);
-        for (let portal of portals) {
-            params.set(`_offset.${portal.toString()}`, (this.portals[portal]?.limit || "").toString());
-            params.set(`_offset.${portal.toString()}`, (this.portals[portal]?.offset || "").toString());
+            params.set('script.prerequest.param', this.scriptData.prerequest.parameter);
+        const portals = Object.keys(this.portals);
+        for (const portal of portals) {
+            params.set(`_offset.${portal.toString()}`, (this.portals[portal]?.limit ?? '').toString());
+            params.set(`_offset.${portal.toString()}`, (this.portals[portal]?.offset ?? '').toString());
         }
         params.set('portal', JSON.stringify(portals));
         return params;
     }
+    /**
+     * Configures any FileMaker scripts to be run as a part of the request
+     *
+     * @param {ScriptRequestData} scripts - The script request data to set.
+     * @return {this} - The current instance of the class.
+     */
     scripts(scripts) {
         this.scriptData = scripts;
         return this;
     }
+    /**
+     * Sorts the data based on the given field name and sort order.
+     *
+     * @param {string} fieldName - The name of the field by which the data should be sorted.
+     * @param {SortOrder} sortOrder - The sort order to be applied (either "asc" for ascending or "desc" for descending).
+     *
+     * @return {this} - Returns the current instance of the object.
+     */
     sort(fieldName, sortOrder) {
         this.sortData.push({ fieldName, sortOrder });
         return this;
     }
     parseFindRequest(query) {
-        let out = {};
-        for (let key of Object.keys(query)) {
+        const out = {};
+        for (const key of Object.keys(query)) {
             out[key] = query[key][FindRequestSymbol].map(item => {
-                if (typeof item === "string")
+                if (typeof item === 'string')
                     return item;
                 // Re-write date into correct format
                 return item
                     .moment
                     .clone()
                     .utcOffset(this.layout.database.host.timezoneOffsetFunc(item.moment))
-                    .format(item.type === "date" ?
-                    this.layout.database.host.dateFormat :
-                    item.type == "time" ?
-                        this.layout.database.host.timeFormat :
-                        this.layout.database.host.timeStampFormat);
-            }).join("");
+                    .format(item.type === 'date'
+                    ? this.layout.database.host.dateFormat
+                    : item.type == 'time'
+                        ? this.layout.database.host.timeFormat
+                        : this.layout.database.host.timeStampFormat);
+            }).join('');
+            console.log(this.layout.database.host.timeStampFormat, out[key]);
         }
         return out;
     }
+    /**
+     * Adds a new request/query to the list of queries.
+     *
+     * @param {FindRequest} query - The find request to be added.
+     * @param {boolean} [omit=false] - Flag to indicate if the find request should be omitted.
+     * @return {Object} - The current object instance.
+     */
     addRequest(query, omit = false) {
         this.queries.push({ req: this.parseFindRequest(query), omit });
         return this;
     }
-    fetch() {
-        return this.performFind(this.offset, this.limit);
+    /**
+     * Perform a fetch operation.
+     *
+     * @returns {Promise} A promise that resolves with the result of the fetch operation.
+     */
+    async fetch() {
+        return await this.performFind(this.offset, this.limit);
     }
     async performFind(offset, limit) {
-        let trace = new Error();
+        const trace = new Error();
         await this.layout.getLayoutMeta();
-        const is_find = this.isFindRequest;
-        let endpoint = this.layout.endpoint + (is_find ? "/_find" : "/records");
-        if (!is_find)
-            endpoint += "?" + new URLSearchParams(this.generateParamsURL(offset, limit)).toString();
+        const isFind = this.isFindRequest;
+        let endpoint = this.layout.endpoint + (isFind ? '/_find' : '/records');
+        if (!isFind)
+            endpoint += '?' + new URLSearchParams(this.generateParamsURL(offset, limit)).toString();
         const reqData = {
             // port: 443,
-            method: is_find ? "POST" : "GET",
-            body: is_find ? JSON.stringify(this.generateParamsBody(offset, limit)) : undefined,
+            method: isFind ? 'POST' : 'GET',
+            body: isFind ? JSON.stringify(this.generateParamsBody(offset, limit)) : undefined
         };
         try {
-            let res = await this.layout.database.apiRequestJSON(endpoint, reqData);
-            if (res.messages[0].code === "0" && res.response) {
+            const res = await this.layout.database._apiRequestJSON(endpoint, reqData);
+            if (res.messages[0].code === '0' && res.response) {
                 // console.log("RESOLVING")
                 if (!this.layout.metadata)
                     await this.layout.getLayoutMeta();
@@ -169,28 +196,28 @@ export class RecordGetOperation {
     }
     [Symbol.asyncIterator]() {
         let nextOffset = this.offset;
-        let startOffset = JSON.parse(JSON.stringify(this.offset));
-        let limit = this.limit;
-        let exit_after_last_record = false;
+        const startOffset = JSON.parse(JSON.stringify(this.offset));
+        const limit = this.limit;
+        let exitAfterLastRecord = false;
         let records = [];
         const fetch = async () => {
-            const theoretical_limit = (limit - nextOffset) + startOffset;
-            if (theoretical_limit === 0) {
-                exit_after_last_record = true;
+            const theoreticalLimit = (limit - nextOffset) + startOffset;
+            if (theoreticalLimit === 0) {
+                exitAfterLastRecord = true;
                 records = [];
                 return;
             }
-            records = await this.performFind(nextOffset, theoretical_limit < 100 ? theoretical_limit : 100);
+            records = await this.performFind(nextOffset, theoreticalLimit < 100 ? theoreticalLimit : 100);
             nextOffset += 100;
             if (records.length < 100)
-                exit_after_last_record = true;
+                exitAfterLastRecord = true;
         };
         return {
             next: async () => {
-                if (records.length === 0 && !exit_after_last_record) {
+                if (records.length === 0 && !exitAfterLastRecord) {
                     await fetch();
                 }
-                if (records.length === 0 && exit_after_last_record) {
+                if (records.length === 0 && exitAfterLastRecord) {
                     return { done: true, value: undefined };
                 }
                 else {