@forge/sql 0.0.1-experimental-9332276 → 0.0.1-experimental-9fa730f

package/README.md

@@ -4,5 +4,9 @@ Usage example:
 ```typescript
 import sql from "@forge/sql";
 
-await sql.execute(`SELECT * FROM example`);
+const result = await sql.execute(`SELECT * FROM example`);
+
+const statement = sql.prepare('INSERT INTO test VALUES (?, ?)');
+
+const result = await statement.bindParams('John Doe', 42).execute();
 ```

package/out/__test__/sql-statement.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sql-statement.test.d.ts.map

package/out/__test__/sql-statement.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-statement.test.d.ts","sourceRoot":"","sources":["../../src/__test__/sql-statement.test.ts"],"names":[],"mappings":""}

package/out/__test__/sql-statement.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sql_statement_1 = require("../sql-statement");
+describe('SqlStatement', () => {
+    let mockRemoteSqlApi;
+    beforeEach(() => {
+        mockRemoteSqlApi = jest.fn().mockResolvedValue({ rows: [] });
+    });
+    it('should initialize with a query and remoteSqlApi function', () => {
+        const sqlStatement = new sql_statement_1.SqlStatement('SELECT * FROM table', mockRemoteSqlApi);
+        expect(sqlStatement).toBeInstanceOf(sql_statement_1.SqlStatement);
+    });
+    it('should bind parameters correctly', () => {
+        const sqlStatement = new sql_statement_1.SqlStatement('SELECT * FROM table WHERE id = ?', mockRemoteSqlApi);
+        const params = [1];
+        sqlStatement.bindParams(...params);
+        expect(sqlStatement['params']).toEqual(params);
+    });
+    it('should execute the query with parameters using remoteSqlApi', async () => {
+        const sqlStatement = new sql_statement_1.SqlStatement('SELECT * FROM table WHERE id = ?', mockRemoteSqlApi);
+        const params = [1];
+        sqlStatement.bindParams(...params);
+        const result = await sqlStatement.execute();
+        expect(mockRemoteSqlApi).toHaveBeenCalledWith('SELECT * FROM table WHERE id = ?', params);
+        expect(result).toEqual({ rows: [] });
+    });
+    it('should handle execution without parameters', async () => {
+        const sqlStatement = new sql_statement_1.SqlStatement('SELECT * FROM table', mockRemoteSqlApi);
+        const result = await sqlStatement.execute();
+        expect(mockRemoteSqlApi).toHaveBeenCalledWith('SELECT * FROM table', []);
+        expect(result).toEqual({ rows: [] });
+    });
+    it('should return result from remoteSqlApi', async () => {
+        const expectedResult = { rows: [{ id: 1, name: 'Test' }] };
+        mockRemoteSqlApi.mockResolvedValueOnce(expectedResult);
+        const sqlStatement = new sql_statement_1.SqlStatement('SELECT * FROM table', mockRemoteSqlApi);
+        const result = await sqlStatement.execute();
+        expect(result).toEqual(expectedResult);
+    });
+});

package/out/__test__/sql.test.js

@@ -1,58 +1,151 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const api_1 = require("@forge/api");
 const sql_1 = require("../sql");
-const reponse_handler_1 = require("../utils/reponse-handler");
-jest.mock('node-fetch');
-const fetchMock = node_fetch_1.default;
-describe('sql', () => {
-    it('should pass', async () => {
-        fetchMock.mockResolvedValueOnce({
-            headers: {
-                has: jest.isMockFunction
-            },
-            ok: true,
-            text: async () => JSON.stringify({
-                values: []
-            })
-        });
-        await sql_1.sql.execute('asdf');
-        expect(fetchMock).toHaveBeenCalled();
-    });
-});
+const sql_statement_1 = require("../sql-statement");
+const response_handler_1 = require("../utils/response-handler");
+jest.mock('@forge/api');
+jest.mock('../sql-statement');
+jest.mock('../utils/response-handler', () => ({
+    ApiError: jest.fn(),
+    getResponseBody: jest.fn()
+}));
 describe('SqlClient', () => {
-    function buildSqlClient() {
-        const fetch = jest.fn();
-        const client = new sql_1.SqlClient(fetch);
-        return { client, fetch };
-    }
-    it('handles success', async () => {
-        const { client, fetch } = buildSqlClient();
-        fetch.mockResolvedValueOnce({
-            ok: true,
-            text: async () => JSON.stringify({ response: 'asdfasdf' }),
-            status: 200
-        });
-        const result = await client.execute('SELECT * FROM example');
-        expect(result).toEqual('asdfasdf');
-        expect(fetch.mock.lastCall).toMatchSnapshot();
+    let sqlClient;
+    let mockFetch;
+    let mockSqlStatement;
+    let mockGetResponseBody;
+    beforeEach(() => {
+        sqlClient = new sql_1.SqlClient();
+        mockFetch = jest.fn();
+        api_1.__fetchProduct.mockReturnValue(mockFetch);
+        mockSqlStatement = {
+            bindParams: jest.fn().mockReturnThis(),
+            execute: jest.fn()
+        };
+        sql_statement_1.SqlStatement.mockImplementation(() => mockSqlStatement);
+        mockGetResponseBody = jest.fn();
+        jest.requireMock('../utils/response-handler').getResponseBody = mockGetResponseBody;
+        jest.clearAllMocks();
+    });
+    describe('sendRequest', () => {
+        it('should send a request with the correct options and return the response', async () => {
+            const mockResponse = { ok: true, status: 200 };
+            mockFetch.mockResolvedValue(mockResponse);
+            const path = 'api/v1/sql/execute';
+            const options = { method: 'GET', headers: { 'Custom-Header': 'value' } };
+            const response = await sqlClient['sendRequest'](path, options);
+            expect(mockFetch).toHaveBeenCalledWith(path, {
+                ...options,
+                redirect: 'follow',
+                headers: {
+                    ...options.headers,
+                    'Content-Type': 'application/json'
+                }
+            });
+            expect(response).toBe(mockResponse);
+        });
+        it('should handle requests without options', async () => {
+            const mockResponse = { ok: true, status: 200 };
+            mockFetch.mockResolvedValue(mockResponse);
+            const path = 'api/v1/sql/execute';
+            const response = await sqlClient['sendRequest'](path);
+            expect(mockFetch).toHaveBeenCalledWith(path, {
+                redirect: 'follow',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            expect(response).toBe(mockResponse);
+        });
+        it('should propagate fetch errors', async () => {
+            const mockError = new Error('Network error');
+            mockFetch.mockRejectedValue(mockError);
+            const path = 'api/v1/sql/execute';
+            await expect(sqlClient['sendRequest'](path)).rejects.toThrow(mockError);
+            expect(mockFetch).toHaveBeenCalledWith(path, expect.any(Object));
+        });
+    });
+    describe('storageApi', () => {
+        it('should send a request and return the response body', async () => {
+            const mockResponse = { text: jest.fn().mockResolvedValue(JSON.stringify({ response: { rows: [] } })) };
+            mockFetch.mockResolvedValue(mockResponse);
+            mockGetResponseBody.mockResolvedValue({ rows: [] });
+            const result = await sqlClient.storageApi('SELECT * FROM test');
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/sql/execute', {
+                method: 'POST',
+                body: JSON.stringify({ query: 'SELECT * FROM test', params: [], method: 'all' }),
+                redirect: 'follow',
+                headers: { 'Content-Type': 'application/json' }
+            });
+            expect(mockGetResponseBody).toHaveBeenCalledWith(mockResponse);
+            expect(result).toEqual({ rows: [] });
+        });
+        it('should send a request with parameters and method', async () => {
+            const mockResponse = { text: jest.fn().mockResolvedValue(JSON.stringify({ response: { rows: [] } })) };
+            mockFetch.mockResolvedValue(mockResponse);
+            mockGetResponseBody.mockResolvedValue({ rows: [] });
+            const params = [1];
+            const result = await sqlClient.storageApi('SELECT * FROM test WHERE id = ?', params, 'one');
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/sql/execute', {
+                method: 'POST',
+                body: JSON.stringify({ query: 'SELECT * FROM test WHERE id = ?', params, method: 'one' }),
+                redirect: 'follow',
+                headers: { 'Content-Type': 'application/json' }
+            });
+            expect(mockGetResponseBody).toHaveBeenCalledWith(mockResponse);
+            expect(result).toEqual({ rows: [] });
+        });
+        it('should handle errors from getResponseBody', async () => {
+            const mockResponse = { text: jest.fn().mockResolvedValue('Invalid JSON') };
+            mockFetch.mockResolvedValue(mockResponse);
+            const mockError = new Error('Invalid JSON');
+            mockGetResponseBody.mockRejectedValue(mockError);
+            await expect(sqlClient.storageApi('INVALID SQL QUERY')).rejects.toThrow(mockError);
+            expect(mockFetch).toHaveBeenCalledWith('api/v1/sql/execute', expect.any(Object));
+            expect(mockGetResponseBody).toHaveBeenCalledWith(mockResponse);
+        });
     });
-    it('handles success when no value is returned', async () => {
-        const { client, fetch } = buildSqlClient();
-        fetch.mockResolvedValueOnce({ ok: true, text: async () => JSON.stringify({ response: null }), status: 200 });
-        const result = await client.execute(`INSERT INTO x SET y='z'`);
-        expect(result).toBeNull();
-        expect(fetch.mock.lastCall).toMatchSnapshot();
+    describe('prepare', () => {
+        it('should return a SqlStatement instance', () => {
+            const statement = sqlClient.prepare('SELECT * FROM test');
+            expect(statement).toBe(mockSqlStatement);
+            expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('SELECT * FROM test', expect.any(Function));
+        });
+        it('should pass the correct query to SqlStatement', () => {
+            sqlClient.prepare('INSERT INTO test VALUES (?, ?)');
+            expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('INSERT INTO test VALUES (?, ?)', expect.any(Function));
+        });
+        it('should pass the storageApi method to SqlStatement', () => {
+            sqlClient.prepare('SELECT * FROM test');
+            const passedFunction = sql_statement_1.SqlStatement.mock.calls[0][1];
+            expect(typeof passedFunction).toBe('function');
+        });
     });
-    it('handles failure', async () => {
-        const { client, fetch } = buildSqlClient();
-        fetch.mockResolvedValueOnce({
-            ok: false,
-            text: async () => JSON.stringify({ error: { code: 'SQL_SYNTAX_ERROR', title: 'SQL syntax error' } }),
-            status: 400
-        });
-        await expect(client.execute('DELECT * from example')).rejects.toThrow(new reponse_handler_1.ApiError(400, 'SQL_SYNTAX_ERROR', 'SQL syntax error'));
-        expect(fetch.mock.lastCall).toMatchSnapshot();
+    describe('execute', () => {
+        it('should execute a query and return the result', async () => {
+            const mockResult = { rows: [{ id: 1, name: 'Test' }] };
+            mockSqlStatement.execute.mockResolvedValue(mockResult);
+            const result = await sqlClient.execute('SELECT * FROM test');
+            expect(result).toEqual(mockResult);
+            expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('SELECT * FROM test', expect.any(Function));
+            expect(mockSqlStatement.execute).toHaveBeenCalled();
+        });
+        it('should execute a query with parameters', async () => {
+            const mockResult = { rows: [{ id: 1, name: 'Test' }] };
+            mockSqlStatement.execute.mockResolvedValue(mockResult);
+            const result = await sqlClient.prepare('SELECT * FROM test WHERE id = ?').bindParams(1).execute();
+            expect(result).toEqual(mockResult);
+            expect(mockSqlStatement.bindParams).toHaveBeenCalledWith(1);
+            expect(mockSqlStatement.execute).toHaveBeenCalled();
+        });
+        it('should handle API errors', async () => {
+            const mockApiError = new response_handler_1.ApiError(400, 'BAD_REQUEST', 'Invalid query');
+            mockSqlStatement.execute.mockRejectedValue(mockApiError);
+            const result = await sqlClient.execute('INVALID SQL QUERY');
+            expect(result).toEqual({ rows: [], err: mockApiError });
+            expect(sql_statement_1.SqlStatement).toHaveBeenCalledWith('INVALID SQL QUERY', expect.any(Function));
+            expect(mockSqlStatement.execute).toHaveBeenCalled();
+        });
     });
 });

package/out/sql-statement.d.ts

@@ -0,0 +1,11 @@
+import { Result } from './utils/types';
+export declare type SqlParameters = any[];
+export declare class SqlStatement {
+    private readonly query;
+    private params;
+    private readonly remoteSqlApi;
+    constructor(query: string, remoteSqlApi: (query: string, params?: SqlParameters, method?: string) => Promise<any>);
+    bindParams(...args: SqlParameters): SqlStatement;
+    execute(): Promise<Result>;
+}
+//# sourceMappingURL=sql-statement.d.ts.map

package/out/sql-statement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-statement.d.ts","sourceRoot":"","sources":["../src/sql-statement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,oBAAY,aAAa,GAAG,GAAG,EAAE,CAAC;AAElC,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA2E;gBAE5F,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;IAMjH,UAAU,CAAC,GAAG,IAAI,EAAE,aAAa,GAAG,YAAY;IAK1C,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;CAGjC"}

package/out/sql-statement.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlStatement = void 0;
+class SqlStatement {
+    query;
+    params;
+    remoteSqlApi;
+    constructor(query, remoteSqlApi) {
+        this.query = query;
+        this.params = [];
+        this.remoteSqlApi = remoteSqlApi;
+    }
+    bindParams(...args) {
+        this.params = args;
+        return this;
+    }
+    async execute() {
+        return this.remoteSqlApi(this.query, this.params);
+    }
+}
+exports.SqlStatement = SqlStatement;

package/out/sql.d.ts

@@ -1,9 +1,9 @@
-import { RequestInit } from 'node-fetch';
-import { Result, Response } from './utils/types';
+import { Result } from './utils/types';
+import { SqlParameters, SqlStatement } from './sql-statement';
 export declare class SqlClient {
-    private client;
-    constructor(client: (path: string, options?: RequestInit) => Promise<Response>);
-    private buildRequest;
+    private sendRequest;
+    storageApi(query: string, params?: SqlParameters, method?: string): Promise<Result>;
+    prepare(query: string): SqlStatement;
     execute(query: string): Promise<Result>;
 }
 export declare const sql: SqlClient;

package/out/sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../src/sql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGjD,qBAAa,SAAS;IACR,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC;IAEtF,OAAO,CAAC,YAAY;IAUP,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAKrD;AAED,eAAO,MAAM,GAAG,WAAyC,CAAC"}
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../src/sql.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAY,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE9D,qBAAa,SAAS;YACN,WAAW;IAYnB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,aAAkB,EAAE,MAAM,SAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;IAQ5F,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY;IAI9B,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAO9C;AAED,eAAO,MAAM,GAAG,WAAkB,CAAC"}

package/out/sql.js

@@ -1,26 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sql = exports.SqlClient = void 0;
-const fetch_wrapper_1 = require("./utils/fetch-wrapper");
-const reponse_handler_1 = require("./utils/reponse-handler");
+const api_1 = require("@forge/api");
+const response_handler_1 = require("./utils/response-handler");
+const sql_statement_1 = require("./sql-statement");
 class SqlClient {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    buildRequest(requestBody) {
-        return {
-            method: 'POST',
-            body: JSON.stringify(requestBody),
+    async sendRequest(path, options) {
+        const response = await (0, api_1.__fetchProduct)({ provider: 'none', remote: 'sql' })(path, {
+            ...options,
+            redirect: 'follow',
             headers: {
+                ...options?.headers,
                 'Content-Type': 'application/json'
             }
-        };
+        });
+        return response;
+    }
+    async storageApi(query, params = [], method = 'all') {
+        const response = await this.sendRequest('api/v1/sql/execute', {
+            method: 'POST',
+            body: JSON.stringify({ query, params, method })
+        });
+        return await (0, response_handler_1.getResponseBody)(response);
+    }
+    prepare(query) {
+        return new sql_statement_1.SqlStatement(query, this.storageApi.bind(this));
     }
     async execute(query) {
-        const response = await this.client('sql/execute', this.buildRequest({ query }));
-        return await (0, reponse_handler_1.getResponseBody)(response);
+        try {
+            return await this.prepare(query).execute();
+        }
+        catch (e) {
+            return { rows: [], err: e };
+        }
     }
 }
 exports.SqlClient = SqlClient;
-exports.sql = new SqlClient((0, fetch_wrapper_1.runtimeV2FetchWrapper)());
+exports.sql = new SqlClient();

package/out/utils/__test__/response-handler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=response-handler.test.d.ts.map

package/out/utils/__test__/response-handler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-handler.test.d.ts","sourceRoot":"","sources":["../../../src/utils/__test__/response-handler.test.ts"],"names":[],"mappings":""}

package/out/utils/__test__/response-handler.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const response_handler_1 = require("../response-handler");
+describe('getResponseBody', () => {
+    it('should return parsed response when response is ok', async () => {
+        const mockResponse = {
+            text: jest.fn().mockResolvedValue(JSON.stringify({ response: { rows: [] } })),
+            ok: true,
+            status: 200
+        };
+        const result = await (0, response_handler_1.getResponseBody)(mockResponse);
+        expect(result).toEqual({ rows: [] });
+    });
+    it('should throw ApiError with parsed error when response is not ok and error JSON is valid', async () => {
+        const mockResponse = {
+            text: jest
+                .fn()
+                .mockResolvedValue(JSON.stringify({ error: { code: 'ERROR_CODE', title: 'Error Title', data: { info: 'detail' } } })),
+            ok: false,
+            status: 400
+        };
+        await expect((0, response_handler_1.getResponseBody)(mockResponse)).rejects.toThrow(response_handler_1.ApiError);
+        await expect((0, response_handler_1.getResponseBody)(mockResponse)).rejects.toMatchObject({
+            status: 400,
+            code: 'ERROR_CODE',
+            message: 'Error Title',
+            data: { info: 'detail' }
+        });
+    });
+    it('should throw ApiError with UNKNOWN_ERROR when response is not ok and error JSON is invalid', async () => {
+        const mockResponse = {
+            text: jest.fn().mockResolvedValue('Invalid JSON'),
+            ok: false,
+            status: 500
+        };
+        await expect((0, response_handler_1.getResponseBody)(mockResponse)).rejects.toThrow(response_handler_1.ApiError);
+        await expect((0, response_handler_1.getResponseBody)(mockResponse)).rejects.toMatchObject({
+            status: 500,
+            code: 'UNKNOWN_ERROR',
+            message: 'Invalid JSON'
+        });
+    });
+    it('should throw Error when response text is not valid JSON', async () => {
+        const mockResponse = {
+            text: jest.fn().mockResolvedValue('Invalid JSON'),
+            ok: true,
+            status: 200
+        };
+        await expect((0, response_handler_1.getResponseBody)(mockResponse)).rejects.toThrowError(new Error('Unexpected error. Response was not valid JSON: Invalid JSON'));
+    });
+});
+describe('ApiError', () => {
+    it('should create an ApiError with correct properties', () => {
+        const error = new response_handler_1.ApiError(404, 'NOT_FOUND', 'Resource not found', { resource: 'User' });
+        expect(error).toBeInstanceOf(Error);
+        expect(error.status).toBe(404);
+        expect(error.code).toBe('NOT_FOUND');
+        expect(error.message).toBe('Resource not found');
+        expect(error.data).toEqual({ resource: 'User' });
+    });
+});

package/out/utils/{reponse-handler.d.ts → response-handler.d.ts}

@@ -1,9 +1,9 @@
-import { Response } from './types';
+import { Response, Result } from './types';
 export declare class ApiError extends Error {
     readonly status: number;
     readonly code: string;
     readonly data?: any;
     constructor(status: number, code: string, message: string, data?: any);
 }
-export declare function getResponseBody(response: Response): Promise<any>;
-//# sourceMappingURL=reponse-handler.d.ts.map
+export declare function getResponseBody(response: Response): Promise<Result>;
+//# sourceMappingURL=response-handler.d.ts.map

package/out/utils/response-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-handler.d.ts","sourceRoot":"","sources":["../../src/utils/response-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAE3C,qBAAa,QAAS,SAAQ,KAAK;IAE/B,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM;IAErB,QAAQ,CAAC,IAAI,CAAC;gBAHL,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACN,IAAI,CAAC,KAAK;CAItB;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BzE"}

package/out/utils/types.d.ts

@@ -1,4 +1,7 @@
-import { Response as nodeFetchResponse } from 'node-fetch';
-export declare type Response = Pick<nodeFetchResponse, 'text' | 'ok' | 'status'>;
-export declare type Result = any;
+import { APIResponse } from '@forge/api';
+export declare type Response = Pick<APIResponse, 'text' | 'ok' | 'status'>;
+export interface Result {
+    rows: any[];
+    err?: Error;
+}
 //# sourceMappingURL=types.d.ts.map

package/out/utils/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC3D,oBAAY,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC;AAEzE,oBAAY,MAAM,GAAG,GAAG,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,oBAAY,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,QAAQ,CAAC,CAAC;AAEnE,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,GAAG,CAAC,EAAE,KAAK,CAAC;CACb"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/sql",
-  "version": "0.0.1-experimental-9332276",
+  "version": "0.0.1-experimental-9fa730f",
   "description": "Forge SQL package",
   "author": "Atlassian",
   "license": "UNLICENSED",
@@ -21,6 +21,6 @@
     "node-fetch": "2.7.0"
   },
   "dependencies": {
-    "@forge/api": "^3.9.0"
+    "@forge/api": "^3.9.1-experimental-9fa730f"
   }
 }

package/out/__test__/fetch-wrapper.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=fetch-wrapper.test.d.ts.map

package/out/__test__/fetch-wrapper.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetch-wrapper.test.d.ts","sourceRoot":"","sources":["../../src/__test__/fetch-wrapper.test.ts"],"names":[],"mappings":""}

package/out/__test__/fetch-wrapper.test.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
-const fetch_wrapper_1 = require("../utils/fetch-wrapper");
-jest.mock('node-fetch');
-const fetchMock = node_fetch_1.default;
-describe('v2', () => {
-    it('chooses the v2 fetch based on runtime', async () => {
-        const fetch = (0, fetch_wrapper_1.runtimeV2FetchWrapper)();
-        fetchMock.mockResolvedValueOnce({
-            headers: {
-                has: jest.isMockFunction
-            },
-            ok: true,
-            json: async () => ({
-                values: []
-            })
-        });
-        await fetch('asdf');
-        expect(fetchMock).toHaveBeenCalled();
-    });
-});

package/out/utils/fetch-wrapper.d.ts

@@ -1,3 +0,0 @@
-import { FetchMethod } from '@forge/api';
-export declare function runtimeV2FetchWrapper(): FetchMethod;
-//# sourceMappingURL=fetch-wrapper.d.ts.map

package/out/utils/fetch-wrapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetch-wrapper.d.ts","sourceRoot":"","sources":["../../src/utils/fetch-wrapper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAqB,MAAM,YAAY,CAAC;AAI5D,wBAAgB,qBAAqB,IAAI,WAAW,CAoBnD"}

package/out/utils/fetch-wrapper.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runtimeV2FetchWrapper = void 0;
-const tslib_1 = require("tslib");
-const api_1 = require("@forge/api");
-const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
-const fetch_1 = require("@forge/api/out/api/fetch");
-function runtimeV2FetchWrapper() {
-    return async (path, init) => {
-        const url = `https://sql/${path}`;
-        init = (0, fetch_1.addMagicAgent)(init);
-        init.redirect = 'follow';
-        init.headers = {
-            ...init.headers,
-            redirect: 'follow',
-            'Content-Type': 'application/json'
-        };
-        const response = await (0, node_fetch_1.default)(url, init);
-        if (response.headers.has('forge-proxy-error')) {
-            throw new api_1.ProxyRequestError(response.status, response.headers.get('forge-proxy-error'));
-        }
-        return response;
-    };
-}
-exports.runtimeV2FetchWrapper = runtimeV2FetchWrapper;

package/out/utils/reponse-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reponse-handler.d.ts","sourceRoot":"","sources":["../../src/utils/reponse-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,qBAAa,QAAS,SAAQ,KAAK;IAE/B,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM;IAErB,QAAQ,CAAC,IAAI,CAAC;gBAHL,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACN,IAAI,CAAC,KAAK;CAItB;AAED,wBAAsB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CA0BtE"}