@forge/sql 2.2.3 → 2.3.0-next.1

package/out/__test__/migration.test.js

@@ -5,6 +5,7 @@ const sql_1 = require("../sql");
 const errorCodes_1 = require("../errorCodes");
 const jest_when_1 = require("jest-when");
 const sql_statement_1 = require("../sql-statement");
+const errors_1 = require("../errors");
 jest.mock('../sql');
 describe('Migration', () => {
     let migrationRunner;
@@ -38,25 +39,25 @@ describe('Migration', () => {
     describe('list', () => {
         it('should list all previously migrations', async () => {
             const migratedAtDate = new Date();
-            mockSqlClient.executeRaw.mockResolvedValueOnce({
+            mockSqlClient.executeDDL.mockResolvedValueOnce({
                 rows: [{ id: 1, name: 'create-table-test', migratedAt: migratedAtDate }]
             });
             const migrations = await migrationRunner.list();
             expect(migrations.length).toBe(1);
             expect(migrations[0]).toEqual({ id: 1, name: 'create-table-test', migratedAt: migratedAtDate });
-            expect(mockSqlClient.executeRaw).toHaveBeenCalledWith('SELECT id, name, migratedAt FROM __migrations;');
+            expect(mockSqlClient.executeDDL).toHaveBeenCalledWith('SELECT id, name, migratedAt FROM __migrations;');
         });
         it('should be empty when no previous migrations exist', async () => {
-            mockSqlClient.executeRaw.mockResolvedValueOnce({
+            mockSqlClient.executeDDL.mockResolvedValueOnce({
                 rows: []
             });
             const migrations = await migrationRunner.list();
             expect(migrations.length).toBe(0);
-            expect(mockSqlClient.executeRaw).toHaveBeenCalledWith('SELECT id, name, migratedAt FROM __migrations;');
+            expect(mockSqlClient.executeDDL).toHaveBeenCalledWith('SELECT id, name, migratedAt FROM __migrations;');
         });
         it('should raise an error when schema version table does not exist', async () => {
             const tableDoesNotExistError = new Error(errorCodes_1.errorCodes.SQL_EXECUTION_ERROR);
-            mockSqlClient.executeRaw.mockRejectedValue(tableDoesNotExistError);
+            mockSqlClient.executeDDL.mockRejectedValue(tableDoesNotExistError);
             await expect(migrationRunner.list()).rejects.toThrow(tableDoesNotExistError);
         });
     });
@@ -72,10 +73,10 @@ describe('Migration', () => {
             it('should execute migrations that have not been previously run', async () => {
                 migrationRunner.enqueue('v_001_create_table_foo', CREATE_TABLE_FOO_QUERY);
                 migrationRunner.enqueue('v_002_create_table_bar', CREATE_TABLE_BAR_QUERY);
-                (0, jest_when_1.when)(mockSqlClient.executeRaw)
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
                     .calledWith((0, jest_when_1.when)((arg) => arg.startsWith('CREATE TABLE IF NOT EXISTS __migrations')))
                     .mockResolvedValue({ rows: [] });
-                (0, jest_when_1.when)(mockSqlClient.executeRaw)
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
                     .calledWith('SELECT id, name, migratedAt FROM __migrations;')
                     .mockResolvedValue({
                     rows: [{ name: 'v_001_create_table_foo', statement: CREATE_TABLE_FOO_QUERY, migratedAt: new Date() }]
@@ -90,7 +91,87 @@ describe('Migration', () => {
                 const result = await migrationRunner.run();
                 expect(result).toEqual(['v_002_create_table_bar']);
                 expect(mockSqlClient.prepare).toHaveBeenCalledTimes(1);
-                expect(mockSqlClient.executeRaw).toHaveBeenCalledTimes(3);
+                expect(mockSqlClient.executeDDL).toHaveBeenCalledTimes(3);
+            });
+            it('should throw forge sql api error during check point', async () => {
+                migrationRunner.enqueue('v_001_create_table_foo', CREATE_TABLE_FOO_QUERY);
+                migrationRunner.enqueue('v_002_create_table_bar', CREATE_TABLE_BAR_QUERY);
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith((0, jest_when_1.when)((arg) => arg.startsWith('CREATE TABLE IF NOT EXISTS __migrations')))
+                    .mockResolvedValue({ rows: [] });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith('SELECT id, name, migratedAt FROM __migrations;')
+                    .mockResolvedValue({
+                    rows: [{ name: 'v_001_create_table_foo', statement: CREATE_TABLE_FOO_QUERY, migratedAt: new Date() }]
+                });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith(CREATE_TABLE_BAR_QUERY)
+                    .mockRejectedValue(new errors_1.ForgeSQLAPIError({ status: 400, statusText: 'Invalid query' }, { code: 'SQL_EXECUTION_ERROR', message: '', suggestion: 'Check your SQL query' }));
+                await expect(migrationRunner.run()).rejects.toMatchObject({
+                    migrationName: 'v_002_create_table_bar',
+                    migrationsYetToRun: ['v_002_create_table_bar'],
+                    cause: new errors_1.ForgeSQLAPIError({ status: 400, statusText: 'Invalid query' }, { code: 'SQL_EXECUTION_ERROR', message: '', suggestion: 'Check your SQL query' })
+                });
+            });
+            it('should throw an error when a migration fails', async () => {
+                migrationRunner.enqueue('v_001_create_table_foo', CREATE_TABLE_FOO_QUERY);
+                migrationRunner.enqueue('v_002_create_table_bar', CREATE_TABLE_BAR_QUERY);
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith((0, jest_when_1.when)((arg) => arg.startsWith('CREATE TABLE IF NOT EXISTS __migrations')))
+                    .mockResolvedValue({ rows: [] });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith('SELECT id, name, migratedAt FROM __migrations;')
+                    .mockResolvedValue({
+                    rows: [{ name: 'v_001_create_table_foo', statement: CREATE_TABLE_FOO_QUERY, migratedAt: new Date() }]
+                });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith(CREATE_TABLE_BAR_QUERY)
+                    .mockRejectedValue(new errors_1.ForgeSQLAPIError({ status: 400, statusText: 'Invalid query' }, { code: 'SQL_EXECUTION_ERROR', message: '', suggestion: 'Check your SQL query' }));
+                await expect(migrationRunner.run()).rejects.toMatchObject({
+                    migrationName: 'v_002_create_table_bar',
+                    migrationsYetToRun: ['v_002_create_table_bar'],
+                    cause: new errors_1.ForgeSQLAPIError({ status: 400, statusText: 'Invalid query' }, { code: 'SQL_EXECUTION_ERROR', message: '', suggestion: 'Check your SQL query' })
+                });
+            });
+            it('should throw generic error when a migration fails', async () => {
+                migrationRunner.enqueue('v_001_create_table_foo', CREATE_TABLE_FOO_QUERY);
+                migrationRunner.enqueue('v_002_create_table_bar', CREATE_TABLE_BAR_QUERY);
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith((0, jest_when_1.when)((arg) => arg.startsWith('CREATE TABLE IF NOT EXISTS __migrations')))
+                    .mockResolvedValue({ rows: [] });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith('SELECT id, name, migratedAt FROM __migrations;')
+                    .mockResolvedValue({
+                    rows: [{ name: 'v_001_create_table_foo', statement: CREATE_TABLE_FOO_QUERY, migratedAt: new Date() }]
+                });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith(CREATE_TABLE_BAR_QUERY)
+                    .mockRejectedValue(new Error('Failed to execute migration'));
+                await expect(migrationRunner.run()).rejects.toMatchObject({
+                    migrationName: 'v_002_create_table_bar',
+                    migrationsYetToRun: ['v_002_create_table_bar'],
+                    cause: new Error('Failed to execute migration')
+                });
+            });
+            it('should throw generic error when check point fails', async () => {
+                migrationRunner.enqueue('v_001_create_table_foo', CREATE_TABLE_FOO_QUERY);
+                migrationRunner.enqueue('v_002_create_table_bar', CREATE_TABLE_BAR_QUERY);
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith((0, jest_when_1.when)((arg) => arg.startsWith('CREATE TABLE IF NOT EXISTS __migrations')))
+                    .mockResolvedValue({ rows: [] });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith('SELECT id, name, migratedAt FROM __migrations;')
+                    .mockResolvedValue({
+                    rows: [{ name: 'v_001_create_table_foo', statement: CREATE_TABLE_FOO_QUERY, migratedAt: new Date() }]
+                });
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
+                    .calledWith(CREATE_TABLE_BAR_QUERY)
+                    .mockRejectedValue(new Error('Failed to execute migration'));
+                await expect(migrationRunner.run()).rejects.toMatchObject({
+                    migrationName: 'v_002_create_table_bar',
+                    migrationsYetToRun: ['v_002_create_table_bar'],
+                    cause: new Error('Failed to execute migration')
+                });
             });
         });
         describe('when no migrations have been run in the past', () => {
@@ -98,10 +179,10 @@ describe('Migration', () => {
                 const CREATE_TABLE_FOO_QUERY = 'CREATE TABLE IF NOT EXISTS foo (id INT)';
                 migrationRunner.enqueue('v_001_create_table_foo', CREATE_TABLE_FOO_QUERY);
                 migrationRunner.enqueue('v_002_create_table_bar', 'CREATE TABLE IF NOT EXISTS bar (id INT)');
-                (0, jest_when_1.when)(mockSqlClient.executeRaw).calledWith('SELECT id, name, migratedAt FROM __migrations;').mockResolvedValue({
+                (0, jest_when_1.when)(mockSqlClient.executeDDL).calledWith('SELECT id, name, migratedAt FROM __migrations;').mockResolvedValue({
                     rows: []
                 });
-                (0, jest_when_1.when)(mockSqlClient.executeRaw)
+                (0, jest_when_1.when)(mockSqlClient.executeDDL)
                     .calledWith((0, jest_when_1.when)((arg) => arg.startsWith('CREATE TABLE IF NOT EXISTS __migrations')))
                     .mockResolvedValue({ rows: [] });
                 const mockApiCall = jest.fn();
@@ -114,7 +195,7 @@ describe('Migration', () => {
                 const result = await migrationRunner.run();
                 expect(result).toEqual(['v_001_create_table_foo', 'v_002_create_table_bar']);
                 expect(mockSqlClient.prepare).toHaveBeenCalledTimes(2);
-                expect(mockSqlClient.executeRaw).toHaveBeenCalledTimes(4);
+                expect(mockSqlClient.executeDDL).toHaveBeenCalledTimes(4);
             });
         });
     });

package/out/__test__/sql.test.js

@@ -21,11 +21,61 @@ describe('SqlClient', () => {
         mockFetch.mockResolvedValue(response);
         return body;
     }
+    describe('storageApi', () => {
+        it('should send a request and return the response body', async () => {
+            mockFetchExecute([]);
+            const result = await sqlClient['storageApi']('SELECT * FROM test', [], undefined, sql_1.SQL_API_ENDPOINTS.EXECUTE);
+            expect(mockFetch).toHaveBeenCalledWith('/api/v1/execute', {
+                method: 'POST',
+                body: JSON.stringify({ query: 'SELECT * FROM test', params: [], method: 'all' }),
+                redirect: 'follow',
+                headers: { 'Content-Type': 'application/json' }
+            });
+            expect(result).toEqual({ rows: [] });
+        });
+        it('should send a request with parameters and method', async () => {
+            mockFetchExecute([]);
+            const params = [1];
+            const result = await sqlClient['storageApi']('SELECT * FROM test WHERE id = ?', params, 'one', sql_1.SQL_API_ENDPOINTS.EXECUTE);
+            expect(mockFetch).toHaveBeenCalledWith('/api/v1/execute', {
+                method: 'POST',
+                body: JSON.stringify({ query: 'SELECT * FROM test WHERE id = ?', params, method: 'one' }),
+                redirect: 'follow',
+                headers: { 'Content-Type': 'application/json' }
+            });
+            expect(result).toEqual({ rows: [] });
+        });
+        it('should send a request to DDL endpoint with method', async () => {
+            mockFetchExecute([]);
+            const result = await sqlClient['storageApi']('CREATE TABLE test (id INT)', [], 'one', sql_1.SQL_API_ENDPOINTS.EXECUTE_DDL);
+            expect(mockFetch).toHaveBeenCalledWith('/api/v1/execute/ddl', {
+                method: 'POST',
+                body: JSON.stringify({ query: 'CREATE TABLE test (id INT)', params: [], method: 'one' }),
+                redirect: 'follow',
+                headers: { 'Content-Type': 'application/json' }
+            });
+            expect(result).toEqual({ rows: [] });
+        });
+        it('should handle invalid JSON body', async () => {
+            const responseText = 'Invalid JSON';
+            const response = new node_fetch_1.Response(responseText, { status: 200 });
+            mockFetch.mockResolvedValue(response);
+            await expect(sqlClient['storageApi']('SELECT * from strange;', [], 'one', sql_1.SQL_API_ENDPOINTS.EXECUTE)).rejects.toThrow(`Unexpected error. Response was not valid JSON: ${responseText}`);
+        });
+        it('should throw ForgeSQLAPIError on API error', async () => {
+            const forgeError = { code: 'INVALID_QUERY', message: 'Invalid SQL query' };
+            const mockResponse = new node_fetch_1.Response(JSON.stringify(forgeError), {
+                status: 400
+            });
+            mockFetch.mockResolvedValue(mockResponse);
+            await expect(sqlClient['storageApi']('INVALID SQL QUERY', [], undefined, sql_1.SQL_API_ENDPOINTS.EXECUTE)).rejects.toThrow(new errors_1.ForgeSQLAPIError({ status: mockResponse.status, statusText: mockResponse.statusText }, forgeError));
+        });
+    });
     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/execute';
+            const path = '/api/v1/execute';
             const options = { method: 'GET', headers: { 'Custom-Header': 'value' } };
             const response = await sqlClient['sendRequest'](path, options);
             expect(mockFetch).toHaveBeenCalledWith(path, {
@@ -41,7 +91,7 @@ describe('SqlClient', () => {
         it('should handle requests without options', async () => {
             const mockResponse = { ok: true, status: 200 };
             mockFetch.mockResolvedValue(mockResponse);
-            const path = 'api/v1/execute';
+            const path = '/api/v1/execute';
             const response = await sqlClient['sendRequest'](path);
             expect(mockFetch).toHaveBeenCalledWith(path, {
                 redirect: 'follow',
@@ -54,50 +104,11 @@ describe('SqlClient', () => {
         it('should propagate fetch errors', async () => {
             const mockError = new Error('Network error');
             mockFetch.mockRejectedValue(mockError);
-            const path = 'api/v1/execute';
+            const path = '/api/v1/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 () => {
-            mockFetchExecute([]);
-            const result = await sqlClient.storageApi('SELECT * FROM test');
-            expect(mockFetch).toHaveBeenCalledWith('api/v1/execute', {
-                method: 'POST',
-                body: JSON.stringify({ query: 'SELECT * FROM test', params: [], method: 'all' }),
-                redirect: 'follow',
-                headers: { 'Content-Type': 'application/json' }
-            });
-            expect(result).toEqual({ rows: [] });
-        });
-        it('should send a request with parameters and method', async () => {
-            mockFetchExecute([]);
-            const params = [1];
-            const result = await sqlClient.storageApi('SELECT * FROM test WHERE id = ?', params, 'one');
-            expect(mockFetch).toHaveBeenCalledWith('api/v1/execute', {
-                method: 'POST',
-                body: JSON.stringify({ query: 'SELECT * FROM test WHERE id = ?', params, method: 'one' }),
-                redirect: 'follow',
-                headers: { 'Content-Type': 'application/json' }
-            });
-            expect(result).toEqual({ rows: [] });
-        });
-        it('should handle invalid JSON body', async () => {
-            const responseText = 'Invalid JSON';
-            const response = new node_fetch_1.Response(responseText, { status: 200 });
-            mockFetch.mockResolvedValue(response);
-            await expect(sqlClient.storageApi('SELECT * from strange;')).rejects.toThrow(`Unexpected error. Response was not valid JSON: ${responseText}`);
-        });
-        it('should throw ForgeSQLAPIError on API error', async () => {
-            const forgeError = { code: 'INVALID_QUERY', message: 'Invalid SQL query' };
-            const mockResponse = new node_fetch_1.Response(JSON.stringify(forgeError), {
-                status: 400
-            });
-            mockFetch.mockResolvedValue(mockResponse);
-            await expect(sqlClient.storageApi('INVALID SQL QUERY')).rejects.toThrow(new errors_1.ForgeSQLAPIError({ status: mockResponse.status, statusText: mockResponse.statusText }, forgeError));
-        });
-    });
     describe('prepare', () => {
         it('should return a SqlStatement instance with query', () => {
             const statement = sqlClient.prepare('INSERT INTO test VALUES (?, ?)');
@@ -156,4 +167,25 @@ describe('SqlClient', () => {
             await expect(sqlClient._provision()).rejects.toThrow('Unexpected error in provision request');
         });
     });
+    describe('executeDDL', () => {
+        it('should return a valid Result object when DDL query gexecuted successfully', async () => {
+            const mockResponse = {
+                ok: true,
+                status: 200,
+                text: jest.fn().mockResolvedValue(JSON.stringify({ success: true }))
+            };
+            mockFetch.mockResolvedValue(mockResponse);
+            const result = await sqlClient.executeDDL('CREATE TABLE test (id INT)');
+            expect(result).toEqual({ success: true });
+            expect(mockFetch).toHaveBeenCalledWith('/api/v1/execute/ddl', expect.objectContaining({ method: 'POST' }));
+        });
+        it('should throw ForgeSQLError when response is not valid JSON', async () => {
+            const forgeError = { code: 'INVALID_QUERY', message: 'Invalid SQL query' };
+            const mockResponse = new node_fetch_1.Response(JSON.stringify(forgeError), {
+                status: 400
+            });
+            mockFetch.mockResolvedValue(mockResponse);
+            await expect(sqlClient.executeDDL('INVALID SQL QUERY')).rejects.toThrow(new errors_1.ForgeSQLAPIError(mockResponse, forgeError));
+        });
+    });
 });

package/out/errors.d.ts

@@ -23,11 +23,13 @@ export declare class ForgeSQLAPIError extends ForgeSQLError {
 export declare class MigrationExecutionError extends ForgeSQLError {
     readonly migrationName: string;
     readonly migrationsYetToRun: string[];
-    constructor(migrationName: string, migrationsYetToRun: string[]);
+    readonly cause?: Error | undefined;
+    constructor(migrationName: string, migrationsYetToRun: string[], cause?: Error | undefined);
 }
 export declare class MigrationCheckPointError extends ForgeSQLError {
     readonly migrationName: string;
     readonly migrationsYetToRun: string[];
-    constructor(migrationName: string, migrationsYetToRun: string[]);
+    readonly cause?: Error | undefined;
+    constructor(migrationName: string, migrationsYetToRun: string[], cause?: Error | undefined);
 }
 //# sourceMappingURL=errors.d.ts.map

package/out/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,UAAU;IAKzB,IAAI,EAAE,MAAM,CAAC;IAGb,OAAO,EAAE,MAAM,CAAC;IAGhB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAGnC;AAGD,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AASD,MAAM,WAAW,uBAAuB;IAEtC,MAAM,EAAE,MAAM,CAAC;IAGf,UAAU,EAAE,MAAM,CAAC;IAGnB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAMD,qBAAa,gBAAiB,SAAQ,aAAa;IAMjD,eAAe,EAAE,uBAAuB,CAAC;IAMzC,IAAI,EAAE,MAAM,CAAC;IAGb,OAAO,EAAE,MAAM,CAAC;IAGhB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEtB,eAAe,EAAE,uBAAuB,EAAE,UAAU,EAAE,UAAU;CAgB7E;AAED,qBAAa,uBAAwB,SAAQ,aAAa;IAEtD,QAAQ,CAAC,aAAa,EAAE,MAAM;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE;gBAD5B,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAAE;CAIxC;AAED,qBAAa,wBAAyB,SAAQ,aAAa;IAEvD,QAAQ,CAAC,aAAa,EAAE,MAAM;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE;gBAD5B,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAAE;CAIxC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,UAAU;IAKzB,IAAI,EAAE,MAAM,CAAC;IAGb,OAAO,EAAE,MAAM,CAAC;IAGhB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAGnC;AAGD,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AASD,MAAM,WAAW,uBAAuB;IAEtC,MAAM,EAAE,MAAM,CAAC;IAGf,UAAU,EAAE,MAAM,CAAC;IAGnB,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAMD,qBAAa,gBAAiB,SAAQ,aAAa;IAMjD,eAAe,EAAE,uBAAuB,CAAC;IAMzC,IAAI,EAAE,MAAM,CAAC;IAGb,OAAO,EAAE,MAAM,CAAC;IAGhB,UAAU,CAAC,EAAE,MAAM,CAAC;IAGpB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAEtB,eAAe,EAAE,uBAAuB,EAAE,UAAU,EAAE,UAAU;CAgB7E;AAED,qBAAa,uBAAwB,SAAQ,aAAa;IAEtD,QAAQ,CAAC,aAAa,EAAE,MAAM;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE;IACrC,QAAQ,CAAC,KAAK,CAAC;gBAFN,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAAE,EAC5B,KAAK,CAAC,mBAAO;CAOzB;AAED,qBAAa,wBAAyB,SAAQ,aAAa;IAEvD,QAAQ,CAAC,aAAa,EAAE,MAAM;IAC9B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE;IACrC,QAAQ,CAAC,KAAK,CAAC;gBAFN,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAAE,EAC5B,KAAK,CAAC,mBAAO;CAOzB"}

package/out/errors.js

@@ -29,20 +29,30 @@ exports.ForgeSQLAPIError = ForgeSQLAPIError;
 class MigrationExecutionError extends ForgeSQLError {
     migrationName;
     migrationsYetToRun;
-    constructor(migrationName, migrationsYetToRun) {
+    cause;
+    constructor(migrationName, migrationsYetToRun, cause) {
         super(`Failed to execute migration with name ${migrationName}`);
         this.migrationName = migrationName;
         this.migrationsYetToRun = migrationsYetToRun;
+        this.cause = cause;
+        this.migrationName = migrationName;
+        this.migrationsYetToRun = migrationsYetToRun;
+        this.cause = cause;
     }
 }
 exports.MigrationExecutionError = MigrationExecutionError;
 class MigrationCheckPointError extends ForgeSQLError {
     migrationName;
     migrationsYetToRun;
-    constructor(migrationName, migrationsYetToRun) {
+    cause;
+    constructor(migrationName, migrationsYetToRun, cause) {
         super(`Failed to checkpoint after running migration with name ${migrationName}`);
         this.migrationName = migrationName;
         this.migrationsYetToRun = migrationsYetToRun;
+        this.cause = cause;
+        this.migrationName = migrationName;
+        this.migrationsYetToRun = migrationsYetToRun;
+        this.cause = cause;
     }
 }
 exports.MigrationCheckPointError = MigrationCheckPointError;

package/out/migration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../src/migration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,aAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,aAAK,gBAAgB,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAcF,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;gBAEnC,SAAS,EAAE,SAAS;IAK1B,UAAU;IAIT,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe;IAQzD,WAAW,IAAI,eAAe,EAAE;IAIjC,IAAI,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAYnC,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAiC/B;AAED,eAAO,MAAM,eAAe,iBAA2B,CAAC"}
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../src/migration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,aAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,aAAK,gBAAgB,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,IAAI,CAAC;CAClB,CAAC;AAcF,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IACtC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;gBAEnC,SAAS,EAAE,SAAS;IAK1B,UAAU;IAIT,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,eAAe;IAQzD,WAAW,IAAI,eAAe,EAAE;IAIjC,IAAI,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAYnC,GAAG,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAmC/B;AAED,eAAO,MAAM,eAAe,iBAA2B,CAAC"}

package/out/migration.js

@@ -14,7 +14,7 @@ class MigrationRunner {
         this.migrations = [];
     }
     async initialize() {
-        await this.sqlClient.executeRaw(SCHEMA_VERSION_TABLE_CREATE_QUERY);
+        await this.sqlClient.executeDDL(SCHEMA_VERSION_TABLE_CREATE_QUERY);
     }
     enqueue(name, statement) {
         if (this.migrations.some((migration) => migration.name === name)) {
@@ -27,7 +27,7 @@ class MigrationRunner {
         return this.migrations;
     }
     async list() {
-        const result = await this.sqlClient.executeRaw(LIST_MIGRATIONS_QUERY);
+        const result = await this.sqlClient.executeDDL(LIST_MIGRATIONS_QUERY);
         const migrations = new Array();
         for (const row of result.rows) {
             const migratedAt = new Date(row.migratedAt);
@@ -44,16 +44,16 @@ class MigrationRunner {
         const migrationsSuccessfullyRun = [];
         for (const migration of migrationsToRun) {
             try {
-                await this.sqlClient.executeRaw(migration.statement);
+                await this.sqlClient.executeDDL(migration.statement);
             }
             catch (error) {
-                throw new errors_1.MigrationExecutionError(migration.name, migrationsToRun.map((m) => m.name));
+                throw new errors_1.MigrationExecutionError(migration.name, migrationsToRun.map((m) => m.name), error);
             }
             try {
                 await this.sqlClient.prepare(INSERT_SCHEMA_VERSION_QUERY).bindParams(migration.name).execute();
             }
             catch (error) {
-                throw new errors_1.MigrationCheckPointError(migration.name, migrationsToRun.map((m) => m.name));
+                throw new errors_1.MigrationCheckPointError(migration.name, migrationsToRun.map((m) => m.name), error);
             }
             migrationsSuccessfullyRun.push(migration.name);
         }

package/out/sql.d.ts

@@ -1,11 +1,19 @@
 import { Result } from './utils/types';
-import { SqlParameters, SqlStatement } from './sql-statement';
+import { SqlStatement } from './sql-statement';
+export declare const SQL_API_ENDPOINTS: {
+    readonly EXECUTE: "/api/v1/execute";
+    readonly EXECUTE_DDL: "/api/v1/execute/ddl";
+};
+declare type SqlAPIEndPoints = (typeof SQL_API_ENDPOINTS)[keyof typeof SQL_API_ENDPOINTS];
 export declare class SqlClient {
     private sendRequest;
-    storageApi<DataType>(query: string, params?: SqlParameters, method?: string): Promise<Result<DataType>>;
-    prepare<DataType>(query: string): SqlStatement<Result<DataType>>;
+    private storageApi;
+    private storageApiWithOptions;
+    prepare<DataType>(query: string, endpoint?: SqlAPIEndPoints): SqlStatement<Result<DataType>>;
     executeRaw<DataType>(query: string): Promise<Result<DataType>>;
     _provision(): Promise<void>;
+    executeDDL<DataType>(query: string): Promise<Result<DataType>>;
 }
 export declare const sql: SqlClient;
+export {};
 //# sourceMappingURL=sql.d.ts.map

package/out/sql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../src/sql.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI9D,qBAAa,SAAS;YACN,WAAW;IAYnB,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,aAAkB,EAAE,MAAM,SAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAiBhH,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAI1D,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAK9D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;CASlC;AAED,eAAO,MAAM,GAAG,WAAkB,CAAC"}
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../src/sql.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAgC,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI7E,eAAO,MAAM,iBAAiB;;;CAGpB,CAAC;AAEX,aAAK,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC;AAElF,qBAAa,SAAS;YACN,WAAW;YAYX,UAAU;YAsBV,qBAAqB;IAYnC,OAAO,CAAC,QAAQ,EACd,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,eAA2C,GACpD,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAU3B,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAK9D,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB3B,UAAU,CAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;CAGrE;AAED,eAAO,MAAM,GAAG,WAAkB,CAAC"}

package/out/sql.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sql = exports.SqlClient = void 0;
+exports.sql = exports.SqlClient = exports.SQL_API_ENDPOINTS = void 0;
 const api_1 = require("@forge/api");
 const sql_statement_1 = require("./sql-statement");
 const error_handling_1 = require("./utils/error-handling");
 const errors_1 = require("./errors");
+exports.SQL_API_ENDPOINTS = {
+    EXECUTE: '/api/v1/execute',
+    EXECUTE_DDL: '/api/v1/execute/ddl'
+};
 class SqlClient {
     async sendRequest(path, options) {
         const response = await (0, api_1.__fetchProduct)({ provider: 'app', remote: 'sql' })(path, {
@@ -17,8 +21,8 @@ class SqlClient {
         });
         return response;
     }
-    async storageApi(query, params = [], method = 'all') {
-        const response = await this.sendRequest('api/v1/execute', {
+    async storageApi(query, params = [], method = 'all', endpoint = exports.SQL_API_ENDPOINTS.EXECUTE) {
+        const response = await this.sendRequest(endpoint, {
             method: 'POST',
             body: JSON.stringify({ query, params, method })
         });
@@ -31,11 +35,16 @@ class SqlClient {
             throw new errors_1.ForgeSQLError(`Unexpected error. Response was not valid JSON: ${responseText}`);
         }
     }
-    prepare(query) {
-        return new sql_statement_1.SqlStatement(query, this.storageApi.bind(this));
+    async storageApiWithOptions(query, options = {}) {
+        const { endpoint = exports.SQL_API_ENDPOINTS.EXECUTE, params = [], method = 'all' } = options;
+        return await this.storageApi(query, params, method, endpoint);
+    }
+    prepare(query, endpoint = exports.SQL_API_ENDPOINTS.EXECUTE) {
+        const remoteSqlApi = (query, params, method) => this.storageApiWithOptions(query, { endpoint, params, method });
+        return new sql_statement_1.SqlStatement(query, remoteSqlApi);
     }
     async executeRaw(query) {
-        return await this.prepare(query).execute();
+        return await this.prepare(query, exports.SQL_API_ENDPOINTS.EXECUTE).execute();
     }
     async _provision() {
         const response = await this.sendRequest('/api/v1/provision', {
@@ -43,6 +52,9 @@ class SqlClient {
         });
         await (0, error_handling_1.checkResponseError)(response, 'Unexpected error in provision request');
     }
+    async executeDDL(query) {
+        return await this.prepare(query, exports.SQL_API_ENDPOINTS.EXECUTE_DDL).execute();
+    }
 }
 exports.SqlClient = SqlClient;
 exports.sql = new SqlClient();

package/out/utils/error-handling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-handling.d.ts","sourceRoot":"","sources":["../../src/utils/error-handling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAA2B,UAAU,EAAoB,MAAM,WAAW,CAAC;AAGlF,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAO9D;AASD,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAuC/F"}
+{"version":3,"file":"error-handling.d.ts","sourceRoot":"","sources":["../../src/utils/error-handling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAA2B,UAAU,EAAoB,MAAM,WAAW,CAAC;AAGlF,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,UAAU,CAO9D;AASD,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsC/F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forge/sql",
-  "version": "2.2.3",
+  "version": "2.3.0-next.1",
   "description": "Forge SQL sdk",
   "author": "Atlassian",
   "license": "UNLICENSED",