feat: move extension creation to core

examples/node-sequelize/migrations/20250110064304-add_timescale_extension.js

@@ -1,12 +1,20 @@
 'use strict';
 
+const { TimescaleDB } = require('@timescaledb/core');
+
+const extension = TimescaleDB.createExtension();
+
 /** @type {import('sequelize-cli').Migration} */
 module.exports = {
   async up(queryInterface) {
-    await queryInterface.sequelize.query('CREATE EXTENSION IF NOT EXISTS timescaledb;');
+    const sql = extension.up().build();
+
+    await queryInterface.sequelize.query(sql);
   },
 
   async down(queryInterface) {
-    await queryInterface.sequelize.query('DROP EXTENSION IF EXISTS timescaledb;');
+    const sql = extension.down().build();
+
+    await queryInterface.sequelize.query(sql);
   },
 };

packages/core/src/errors.ts

@@ -3,3 +3,7 @@ export enum HypertableErrors {
   OPTIONS_REQUIRED = 'Hypertable options are required',
   INVALID_OPTIONS = 'Invalid hypertable options',
 }
+
+export enum ExtensionErrors {
+  INVALID_OPTIONS = 'Invalid extension options',
+}

packages/core/src/extension.ts

@@ -0,0 +1,57 @@
+import { CreateExtensionOptions, CreateExtensionOptionsSchema } from '@timescaledb/schemas';
+import { ExtensionErrors } from './errors';
+
+class ExtensionUpBuilder {
+  private options?: CreateExtensionOptions;
+  private statements: string[] = [];
+
+  constructor(options?: CreateExtensionOptions) {
+    this.options = options;
+  }
+
+  public build(): string {
+    const stmt = `CREATE EXTENSION IF NOT EXISTS timescaledb${this?.options?.should_cascade ? ' CASCADE' : ''};`;
+    this.statements.push(stmt);
+
+    return this.statements.join('\n');
+  }
+}
+
+class ExtensionDownBuilder {
+  private options?: CreateExtensionOptions;
+  private statements: string[] = [];
+
+  constructor(options?: CreateExtensionOptions) {
+    this.options = options;
+  }
+
+  public build(): string {
+    const stmt = `DROP EXTENSION IF EXISTS timescaledb${this?.options?.should_cascade ? ' CASCADE' : ''};`;
+    this.statements.push(stmt);
+
+    return this.statements.join('\n');
+  }
+}
+
+export class Extension {
+  private options?: CreateExtensionOptions;
+
+  constructor(options?: CreateExtensionOptions) {
+    if (options) {
+      try {
+        this.options = CreateExtensionOptionsSchema.parse(options);
+      } catch (error) {
+        const e = error as Error;
+        throw new Error(ExtensionErrors.INVALID_OPTIONS + ' ' + e.message);
+      }
+    }
+  }
+
+  public up(): ExtensionUpBuilder {
+    return new ExtensionUpBuilder(this.options);
+  }
+
+  public down(): ExtensionDownBuilder {
+    return new ExtensionDownBuilder(this.options);
+  }
+}

packages/core/src/index.ts

@@ -1,5 +1,6 @@
-import { CreateHypertableOptions } from '@timescaledb/schemas';
+import { CreateExtensionOptions, CreateHypertableOptions } from '@timescaledb/schemas';
 import { Hypertable } from './hypertable';
+import { Extension } from './extension';
 
 export const name = '@timescaledb/core';
 
@@ -11,6 +12,12 @@ export class TimescaleDB {
 
     return hypertable;
   }
+
+  public static createExtension(options?: CreateExtensionOptions): Extension {
+    const extension = new Extension(options);
+
+    return extension;
+  }
 }
 
 export * from './errors';

packages/core/tests/__snapshots__/extension.test.ts.snap

@@ -0,0 +1,9 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Extension down should drop an extension 1`] = `"DROP EXTENSION IF EXISTS timescaledb;"`;
+
+exports[`Extension down should drop an extension with cascade 1`] = `"DROP EXTENSION IF EXISTS timescaledb CASCADE;"`;
+
+exports[`Extension up should create an extension 1`] = `"CREATE EXTENSION IF NOT EXISTS timescaledb;"`;
+
+exports[`Extension up should create an extension with cascade 1`] = `"CREATE EXTENSION IF NOT EXISTS timescaledb CASCADE;"`;

packages/core/tests/extension.test.ts

@@ -0,0 +1,49 @@
+import { describe, it } from '@jest/globals';
+import { TimescaleDB, ExtensionErrors } from '../src';
+
+describe('Extension', () => {
+  it('should fail when creating an extension without invalid options', () => {
+    expect(() => {
+      TimescaleDB.createExtension({
+        // @ts-expect-error
+        invalidOption: 'invalid',
+      });
+    }).toThrow(ExtensionErrors.INVALID_OPTIONS);
+  });
+
+  describe('up', () => {
+    it('should create an extension', () => {
+      const extension = TimescaleDB.createExtension();
+      const sql = extension.up().build();
+
+      expect(sql).toMatchSnapshot();
+    });
+
+    it('should create an extension with cascade', () => {
+      const extension = TimescaleDB.createExtension({
+        should_cascade: true,
+      });
+      const sql = extension.up().build();
+
+      expect(sql).toMatchSnapshot();
+    });
+  });
+
+  describe('down', () => {
+    it('should drop an extension', () => {
+      const extension = TimescaleDB.createExtension();
+      const sql = extension.down().build();
+
+      expect(sql).toMatchSnapshot();
+    });
+
+    it('should drop an extension with cascade', () => {
+      const extension = TimescaleDB.createExtension({
+        should_cascade: true,
+      });
+      const sql = extension.down().build();
+
+      expect(sql).toMatchSnapshot();
+    });
+  });
+});

packages/schemas/src/extension.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const CreateExtensionOptionsSchema = z
+  .object({
+    should_cascade: z.boolean().optional(),
+    version: z.string().optional(),
+  })
+  .strict();
+export type CreateExtensionOptions = z.infer<typeof CreateExtensionOptionsSchema>;

packages/schemas/src/index.ts

@@ -2,3 +2,4 @@ export * from './compression';
 export * from './time-range';
 export * from './hypertable';
 export * from './by-range';
+export * from './extension';