tantan-typeorm-gs 1.0.0

package/test/google-sheets/0007-performance.test.ts

@@ -0,0 +1,532 @@
+import { describe, expect, test } from 'bun:test';
+import
+{
+    Column,
+    Entity,
+    PrimaryGeneratedColumn,
+} from 'typeorm';
+import { Memory } from '../../src/core/memory';
+import { createGoogleSheetsDataSource, type GoogleSheetsRow } from '../../src';
+
+
+describe(
+    'Google Sheets API Performance',
+    () =>
+    {
+        @Entity('performance_users')
+        class PerformanceUser
+        {
+            @PrimaryGeneratedColumn()
+            id!: number;
+
+            @Column()
+            name!: string;
+
+            @Column()
+            email!: string;
+        }
+
+        async function createDataSource(
+            rows: GoogleSheetsRow[] = [],
+        )
+        {
+            const client =
+                new Memory({
+                    performance_users: rows,
+                });
+
+            await client.insertHeaders(
+                'performance_users',
+                [
+                    'id',
+                    'name',
+                    'email',
+                ],
+            );
+
+            const dataSource =
+                createGoogleSheetsDataSource({
+                    type: 'google-sheets',
+                    client,
+                    entities: [
+                        PerformanceUser,
+                    ],
+                });
+
+            await dataSource.initialize();
+
+            return {
+                client,
+                dataSource,
+            };
+        }
+
+        test('should insert 100 rows within acceptable time',
+            async () =>
+            {
+                const {
+                    client,
+                    dataSource,
+                } =
+                    await createDataSource();
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const users =
+                        Array.from(
+                            {
+                                length: 1000,
+                            },
+                            (_, index) => ({
+                                name:
+                                    `User ${index + 1} `,
+                                email:
+                                    `user${index + 1} @example.com`,
+                            }),
+                        );
+
+                    const start =
+                        performance.now();
+
+                    await repository.insert(
+                        users,
+                    );
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    const rows =
+                        await client.getRows(
+                            'performance_users',
+                        );
+
+                    expect(rows)
+                        .toHaveLength(1000);
+
+                    expect(elapsed)
+                        .toBeLessThan(5000);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+
+        test(
+            'should read 100 rows within acceptable time',
+            async () =>
+            {
+                const rows =
+                    Array.from(
+                        {
+                            length: 100,
+                        },
+                        (_, index) => ({
+                            id: index + 1,
+                            name:
+                                `User ${index + 1} `,
+                            email:
+                                `user${index + 1} @example.com`,
+                        }),
+                    );
+
+                const {
+                    dataSource,
+                } =
+                    await createDataSource(rows);
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const start =
+                        performance.now();
+
+                    const users =
+                        await repository.find();
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    expect(users)
+                        .toHaveLength(100);
+
+                    expect(elapsed)
+                        .toBeLessThan(300);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+
+        test('should insert 1000 rows within acceptable time',
+            async () =>
+            {
+                const {
+                    client,
+                    dataSource,
+                } =
+                    await createDataSource();
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const users =
+                        Array.from(
+                            {
+                                length: 1000,
+                            },
+                            (_, index) => ({
+                                name:
+                                    `User ${index + 1} `,
+                                email:
+                                    `user${index + 1} @example.com`,
+                            }),
+                        );
+
+                    const start =
+                        performance.now();
+
+                    await repository.insert(
+                        users,
+                    );
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    const rows =
+                        await client.getRows(
+                            'performance_users',
+                        );
+
+                    expect(rows)
+                        .toHaveLength(1000);
+
+                    expect(elapsed)
+                        .toBeLessThan(1000);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+
+        test(
+            'should read 1000 rows within acceptable time',
+            async () =>
+            {
+                const rows =
+                    Array.from(
+                        {
+                            length: 1000,
+                        },
+                        (_, index) => ({
+                            id: index + 1,
+                            name:
+                                `User ${index + 1} `,
+                            email:
+                                `user${index + 1} @example.com`,
+                        }),
+                    );
+
+                const {
+                    dataSource,
+                } =
+                    await createDataSource(rows);
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const start =
+                        performance.now();
+
+                    const users =
+                        await repository.find();
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    expect(users)
+                        .toHaveLength(1000);
+
+                    expect(elapsed)
+                        .toBeLessThan(1000);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+
+        test('should insert 10000 rows within acceptable time',
+            async () =>
+            {
+                const {
+                    client,
+                    dataSource,
+                } =
+                    await createDataSource();
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const users =
+                        Array.from(
+                            {
+                                length: 10000,
+                            },
+                            (_, index) => ({
+                                name:
+                                    `User ${index + 1} `,
+                                email:
+                                    `user${index + 1} @example.com`,
+                            }),
+                        );
+
+                    const start =
+                        performance.now();
+
+                    await repository.insert(
+                        users,
+                    );
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    const rows =
+                        await client.getRows(
+                            'performance_users',
+                        );
+
+                    expect(rows)
+                        .toHaveLength(10000);
+
+                    expect(elapsed)
+                        .toBeLessThan(3000);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+
+        test(
+            'should read 10000 rows within acceptable time',
+            async () =>
+            {
+                const rows =
+                    Array.from(
+                        {
+                            length: 10000,
+                        },
+                        (_, index) => ({
+                            id: index + 1,
+                            name:
+                                `User ${index + 1} `,
+                            email:
+                                `user${index + 1} @example.com`,
+                        }),
+                    );
+
+                const {
+                    dataSource,
+                } =
+                    await createDataSource(rows);
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const start =
+                        performance.now();
+
+                    const users =
+                        await repository.find();
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    expect(users)
+                        .toHaveLength(10000);
+
+                    expect(elapsed)
+                        .toBeLessThan(3000);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+
+        test('should insert 100000 rows within acceptable time',
+            async () =>
+            {
+                const {
+                    client,
+                    dataSource,
+                } =
+                    await createDataSource();
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const users =
+                        Array.from(
+                            {
+                                length: 100000,
+                            },
+                            (_, index) => ({
+                                name:
+                                    `User ${index + 1} `,
+                                email:
+                                    `user${index + 1} @example.com`,
+                            }),
+                        );
+
+                    const start =
+                        performance.now();
+
+                    await repository.insert(
+                        users,
+                    );
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    const rows =
+                        await client.getRows(
+                            'performance_users',
+                        );
+
+                    expect(rows)
+                        .toHaveLength(100000);
+
+                    expect(elapsed)
+                        .toBeLessThan(5000);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+
+        test(
+            'should read 100000 rows within acceptable time',
+            async () =>
+            {
+                const rows =
+                    Array.from(
+                        {
+                            length: 100000,
+                        },
+                        (_, index) => ({
+                            id: index + 1,
+                            name:
+                                `User ${index + 1} `,
+                            email:
+                                `user${index + 1} @example.com`,
+                        }),
+                    );
+
+                const {
+                    dataSource,
+                } =
+                    await createDataSource(rows);
+
+                try
+                {
+                    const repository =
+                        dataSource.getRepository(
+                            PerformanceUser,
+                        );
+
+                    const start =
+                        performance.now();
+
+                    const users =
+                        await repository.find();
+
+                    const elapsed =
+                        performance.now() -
+                        start;
+
+                    expect(users)
+                        .toHaveLength(100000);
+
+                    expect(elapsed)
+                        .toBeLessThan(5000);
+                }
+                finally
+                {
+                    if (dataSource.isInitialized)
+                    {
+                        await dataSource.destroy();
+                    }
+                }
+            },
+        );
+    },
+);

package/test/public-api.test.ts

@@ -0,0 +1,34 @@
+import { createGoogleSheetsDataSource, GoogleSheetsConsume } from '../src/index';
+import type {
+    GoogleSheetsDataSourceOptions,
+    GoogleSheetsClient,
+    GoogleSheetsRow,
+} from '../src/index';
+
+import { describe, expect, test } from 'bun:test';
+
+describe('public API', () =>
+{
+    test('exports public runtime API', () =>
+    {
+        expect(createGoogleSheetsDataSource).toBeFunction();
+        expect(GoogleSheetsConsume).toBeFunction();
+    });
+
+    test('exports public types', () =>
+    {
+        const client: GoogleSheetsClient =
+            {} as GoogleSheetsClient;
+
+        const options:
+            GoogleSheetsDataSourceOptions =
+            {} as GoogleSheetsDataSourceOptions;
+
+        const row: GoogleSheetsRow =
+            {} as GoogleSheetsRow;
+
+        expect(client).toBeDefined();
+        expect(options).toBeDefined();
+        expect(row).toBeDefined();
+    });
+});

package/tsconfig.build.json

@@ -0,0 +1,21 @@
+{
+	"extends": "./tsconfig.json",
+
+	"compilerOptions": {
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+
+		"noEmit": false,
+
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+
+		"outDir": "./dist",
+		"rootDir": "./src",
+
+		"allowImportingTsExtensions": false
+	},
+	"include": ["src/**/*.ts"],
+	"exclude": ["node_modules", "test"]
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+	"compilerOptions": {
+		// Environment setup & latest features
+		"lib": ["ESNext"],
+		"target": "ESNext",
+		"module": "Preserve",
+		"moduleDetection": "force",
+		"jsx": "react-jsx",
+		"allowJs": true,
+		"types": ["bun"],
+
+		// Bundler mode
+		"moduleResolution": "bundler",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"noEmit": true,
+
+		// Best practices
+		"strict": true,
+		"skipLibCheck": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedIndexedAccess": true,
+		"noImplicitOverride": true,
+
+		// Some stricter flags (disabled by default)
+		"noUnusedLocals": false,
+		"noUnusedParameters": false,
+		"noPropertyAccessFromIndexSignature": false,
+		"experimentalDecorators": true,
+		"emitDecoratorMetadata": true
+	},
+	"include": ["src/**/*.ts", "test/**/*.ts"],
+	"exclude": ["node_modules", "dist"]
+}