tantan-typeorm-gs 1.0.0

package/src/core/query/types.ts

@@ -0,0 +1,155 @@
+import type { GoogleSheetsRow } from "../types.js";
+
+export interface InsertQuery
+{
+    columns: string[];
+    values: string[][];
+}
+
+export interface UpdateQuery
+{
+    table: string;
+    assignments: {
+        column: string;
+        value: string;
+    }[];
+    where: WhereExpression;
+}
+
+export interface DeleteQuery
+{
+    table: string;
+    where: WhereExpression;
+}
+
+export interface SelectColumn
+{
+    tableAlias: string;
+    column: string;
+    alias: string;
+}
+
+export interface FromQuery
+{
+    table: string;
+    alias: string;
+}
+
+export type JoinType =
+    | 'LEFT'
+    | 'INNER';
+
+export type JoinOperand =
+    | {
+        type: 'column';
+        tableAlias: string;
+        column: string;
+    }
+    | {
+        type: 'parameter';
+        value: string;
+    };
+
+export type JoinConditionOperator =
+    | '='
+    | 'IS NULL'
+    | 'IS NOT NULL';
+
+export interface JoinCondition
+{
+    left: JoinOperand;
+    operator: JoinConditionOperator;
+    right?: JoinOperand;
+}
+
+export interface JoinQuery
+{
+    type: JoinType;
+    table: string;
+    alias: string;
+    conditions: JoinCondition[];
+}
+
+export type JoinedRow = Record<string, GoogleSheetsRow | undefined>;
+
+/**
+ * Operators generated by TypeORM FindOperator
+ * that can be evaluated by the Google Sheets driver.
+ */
+export type WhereOperator =
+    | '='
+    | '!='
+    | '<>'
+    | '>'
+    | '>='
+    | '<'
+    | '<='
+    | 'IS NULL'
+    | 'IS NOT NULL'
+    | 'IN'
+    | 'NOT IN'
+    | 'ANY'
+    | 'LIKE'
+    | 'NOT LIKE'
+    | 'ILIKE'
+    | 'NOT ILIKE'
+    | 'BETWEEN';
+
+export interface WhereCondition
+{
+    tableAlias: string;
+    column: string;
+    operator: WhereOperator;
+    parameters: string[];
+}
+
+
+export type WhereExpression =
+    | {
+        type: 'condition';
+        condition: WhereCondition;
+    }
+    | {
+        type: 'and';
+        expressions: WhereExpression[];
+    }
+    | {
+        type: 'or';
+        expressions: WhereExpression[];
+    }
+    | {
+        type: 'not';
+        expression: WhereExpression;
+    };
+
+
+export type AggregateFunction =
+    | 'COUNT'
+    | 'SUM'
+    | 'AVG'
+    | 'MIN'
+    | 'MAX';
+
+export interface AggregateColumn
+{
+    function: AggregateFunction;
+    argument: string;
+    alias: string;
+}
+
+export type OrderDirection =
+    | 'ASC'
+    | 'DESC';
+
+export interface OrderBy
+{
+    tableAlias: string;
+    column: string;
+    direction: OrderDirection;
+}
+
+export interface Pagination
+{
+    limit?: number;
+    offset?: number;
+}

package/src/core/schema-builder.ts

@@ -0,0 +1,64 @@
+import type { DataSource } from "typeorm";
+import type { SqlInMemory } from "typeorm/driver/SqlInMemory.js";
+import type { SchemaBuilder } from "typeorm/schema-builder/SchemaBuilder.js";
+import type { GoogleSheetsDriver } from "./driver.js";
+
+export class GoogleSheetsSchemaBuilder implements SchemaBuilder
+{
+    constructor(
+        private readonly connection: DataSource,
+        private readonly driver: GoogleSheetsDriver
+    ) { }
+
+    async build(): Promise<void>
+    {
+        const metadatas = this.connection.entityMetadatas;
+
+        for (const metadata of metadatas)
+        {
+            if (!metadata.synchronize) continue;
+
+            const sheetName =
+                this.driver.buildTableName(
+                    metadata.tableName,
+                    metadata.schema,
+                    metadata.database,
+                );
+
+            const exists = await this.driver.client.hasSheet(sheetName);
+
+            if (!exists)
+            {
+                await this.driver.client.createSheet(sheetName);
+
+                this.connection.logger.logSchemaBuild(`Created sheet "${sheetName}"`);
+
+                const headers = metadata.columns.map((column) => column.databaseName);
+
+                await this.driver.client.insertHeaders(sheetName, headers);
+
+                this.connection.logger.logSchemaBuild(`Created columns for "${sheetName}": ${headers.join(', ')}`);
+
+                continue;
+            }
+
+            const existingHeaders = await this.driver.client.getHeaders(sheetName);
+
+            const metadataHeaders = metadata.columns.map((column) => column.databaseName);
+
+            const missingHeaders = metadataHeaders.filter((header) => !existingHeaders.includes(header));
+
+            if (missingHeaders.length === 0) continue;
+
+            await this.driver.client.insertHeaders(sheetName, [...existingHeaders, ...missingHeaders]);
+
+            this.connection.logger.logSchemaBuild(`Added columns to "${sheetName}": ${missingHeaders.join(', ')}`);
+        }
+    }
+
+    log(): Promise<SqlInMemory>
+    {
+        throw new Error("Method not implemented.");
+    }
+
+}

package/src/core/types.ts

@@ -0,0 +1,113 @@
+import type { DataSourceOptions } from "typeorm";
+
+export interface GoogleSheetsDataSourceOptionsBase
+{
+    type: 'google-sheets';
+
+    entities?: DataSourceOptions['entities'];
+    subscribers?: DataSourceOptions['subscribers'];
+    migrations?: DataSourceOptions['migrations'];
+
+    synchronize?: boolean;
+    migrationsRun?: boolean;
+    dropSchema?: boolean;
+
+    logging?: DataSourceOptions['logging'];
+    logger?: DataSourceOptions['logger'];
+
+    name?: string;
+}
+
+export interface GoogleSheetsCredentials
+{
+    clientEmail: string;
+    privateKey: string;
+}
+
+export interface GoogleSheetsConsumeOptions
+{
+    spreadsheetId: string;
+    credentials: GoogleSheetsCredentials;
+}
+
+export interface GoogleSheetsDataSourceWithClientOptions extends GoogleSheetsDataSourceOptionsBase
+{
+    client: GoogleSheetsClient;
+}
+
+export interface GoogleSheetsDataSourceWithCredentialsOptions extends GoogleSheetsDataSourceOptionsBase
+{
+    spreadsheetId: string;
+    credentials: GoogleSheetsCredentials;
+
+    client?: GoogleSheetsClient;
+}
+
+export type GoogleSheetsDataSourceOptions =
+    | GoogleSheetsDataSourceWithClientOptions
+    | GoogleSheetsDataSourceWithCredentialsOptions;
+
+export interface GoogleSheetsClient
+{
+    connect(): Promise<void>;
+
+    disconnect(): Promise<void>;
+
+    hasSheet(
+        sheetName: string,
+    ): Promise<boolean>;
+
+    createSheet(sheetName: string): Promise<void>;
+
+    getSheetMetadata(
+        sheetName: string,
+    ): Promise<GoogleSheetsSheetMetadata | null>;
+
+    getHeaders(
+        sheetName: string,
+    ): Promise<string[]>;
+
+    insertHeaders(
+        sheetName: string,
+        headers: string[],
+    ): Promise<void>;
+
+    renameSheet(
+        oldSheetName: string,
+        newSheetName: string,
+    ): Promise<void>;
+
+    deleteSheet(
+        sheetName: string,
+    ): Promise<void>;
+
+    getRows(
+        sheetName: string,
+    ): Promise<GoogleSheetsRow[]>;
+
+    insertRows(
+        sheetName: string,
+        rows: GoogleSheetsRow[],
+    ): Promise<void>;
+
+    updateRows(
+        sheetName: string,
+        predicate: (row: GoogleSheetsRow) => boolean,
+        update: Partial<GoogleSheetsRow>,
+    ): Promise<number>;
+
+    deleteRows(
+        sheetName: string,
+        predicate: (row: GoogleSheetsRow) => boolean,
+    ): Promise<number>;
+}
+
+export type GoogleSheetsRow = Record<string, unknown>;
+
+export interface GoogleSheetsSheetMetadata
+{
+    sheetId: number;
+    title: string;
+}
+
+export const DEFAULT_MAX_RETRIES = 3;

package/src/core/utils.ts

@@ -0,0 +1,13 @@
+export function validateWorksheetName(sheetName: string): void
+{
+    if (sheetName.length === 0) throw new Error('Worksheet name cannot be empty.');
+    if (sheetName.length > 100) throw new Error('Worksheet name cannot exceed 100 characters.');
+    if (/[:\\/?*\[\]]/.test(sheetName)) throw new Error('Worksheet name contains invalid characters.');
+}
+
+export function buildWorksheetRange(sheetName: string, range: string): string
+{
+    const escapedSheetName = `'${sheetName.replace(/'/g, "''")}'`;
+
+    return `${escapedSheetName}!${range}`;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export type { GoogleSheetsDataSourceOptions, GoogleSheetsClient, GoogleSheetsRow } from './core/types.js';
+export { createGoogleSheetsDataSource } from './core/data-source.js';
+export { GoogleSheetsConsume } from './client/index.js';

package/tantan-typeorm-gs.code-workspace

@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}

package/test/base/0001-data-source.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, test } from 'bun:test';
+import { Column, CreateDateColumn, Entity, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { Memory } from '../../src/core/memory';
+import { createGoogleSheetsDataSource } from '../../src/core/data-source';
+
+describe('GoogleSheetsDataSource', () =>
+{
+    @Entity()
+    class User
+    {
+        @PrimaryGeneratedColumn()
+        id!: number;
+
+        @Column()
+        name!: string;
+    }
+
+    @Entity()
+    class DataTypeUser
+    {
+        @PrimaryGeneratedColumn()
+        id!: number;
+
+        @Column()
+        name!: string;
+
+        @Column()
+        age!: number;
+
+        @Column()
+        active!: boolean;
+
+        @Column()
+        createdAt!: Date;
+    }
+
+    @Entity()
+    class TimestampUser
+    {
+        @PrimaryGeneratedColumn()
+        id!: number;
+
+        @Column()
+        name!: string;
+
+        @CreateDateColumn()
+        createdAt!: Date;
+
+        @UpdateDateColumn()
+        updatedAt!: Date;
+    }
+
+    test('creates DataSource with GoogleSheetsDriver', () =>
+    {
+        const dataSource = createGoogleSheetsDataSource({
+            type: 'google-sheets',
+            client: new Memory(),
+        });
+
+        expect(dataSource.driver.constructor.name)
+            .toBe('GoogleSheetsDriver');
+
+        expect(dataSource.manager.constructor.name)
+            .toBe('EntityManager');
+    });
+
+    test('initializes and builds entity metadata', async () =>
+    {
+        const dataSource = createGoogleSheetsDataSource({
+            type: 'google-sheets',
+            client: new Memory(),
+            entities: [User],
+        });
+
+        await dataSource.initialize();
+
+        expect(dataSource.isInitialized).toBe(true);
+        expect(dataSource.entityMetadatas).toHaveLength(1);
+
+        const metadata = dataSource.getMetadata(User);
+
+        expect(metadata.tableName).toBe('user');
+        expect(metadata.columns).toHaveLength(2);
+
+        await dataSource.destroy();
+    });
+
+    test('creates repository', async () =>
+    {
+        const dataSource = createGoogleSheetsDataSource({
+            type: 'google-sheets',
+            client: new Memory(),
+            entities: [User],
+        });
+
+        await dataSource.initialize();
+
+        const repository = dataSource.getRepository(User);
+
+        expect(repository.metadata).toBe(dataSource.getMetadata(User));
+        expect(repository.target).toBe(User);
+
+        await dataSource.destroy();
+    });
+
+    test('saves supported column data types', async () =>
+    {
+        const client =
+            new Memory();
+
+        const dataSource =
+            createGoogleSheetsDataSource({
+                type: 'google-sheets',
+                client,
+                entities: [
+                    DataTypeUser,
+                ]
+            });
+
+        await dataSource.initialize();
+
+        const user =
+            dataSource
+                .getRepository(DataTypeUser)
+                .create({
+                    name: 'John',
+                    age: 30,
+                    active: true,
+                    createdAt: new Date(),
+                });
+
+        await dataSource
+            .getRepository(DataTypeUser)
+            .save(user);
+
+        const result =
+            await dataSource
+                .getRepository(DataTypeUser)
+                .findOneBy({
+                    id: user.id,
+                });
+
+        expect(result)
+            .toBeDefined();
+
+        expect(result?.name)
+            .toBe('John');
+
+        expect(result?.age)
+            .toBe(30);
+
+        expect(result?.active)
+            .toBe(true);
+
+        expect(result?.createdAt)
+            .toEqual(user.createdAt);
+    });
+
+    test('assigns create and update dates when saving a new entity', async () =>
+    {
+        const client =
+            new Memory();
+
+        const dataSource =
+            createGoogleSheetsDataSource({
+                type: 'google-sheets',
+                client,
+                entities: [
+                    TimestampUser,
+                ]
+            });
+
+        await dataSource.initialize();
+
+        const user =
+            dataSource
+                .getRepository(TimestampUser)
+                .create({
+                    name: 'John',
+                });
+
+        await dataSource
+            .getRepository(TimestampUser)
+            .save(user);
+
+        expect(user.createdAt)
+            .toBeInstanceOf(Date);
+
+        expect(user.updatedAt)
+            .toBeInstanceOf(Date);
+
+        expect(user.createdAt.getTime())
+            .toBeLessThanOrEqual(
+                user.updatedAt.getTime(),
+            );
+    });
+
+    test('updates update date when updating an existing entity', async () =>
+    {
+        const client =
+            new Memory();
+
+        const dataSource =
+            createGoogleSheetsDataSource({
+                type: 'google-sheets',
+                client,
+                entities: [
+                    TimestampUser,
+                ]
+            });
+
+        await dataSource.initialize();
+
+        const repository =
+            dataSource.getRepository(TimestampUser);
+
+        const user =
+            repository.create({
+                name: 'John',
+            });
+
+        await repository.save(user);
+
+        const createdAt =
+            user.createdAt.getTime();
+
+        const updatedAt =
+            user.updatedAt.getTime();
+
+        await new Promise(
+            (resolve) =>
+                setTimeout(resolve, 5),
+        );
+
+        user.name = 'Jane';
+
+        await repository.save(user);
+
+        expect(user.createdAt)
+            .toBeInstanceOf(Date);
+
+        expect(user.updatedAt)
+            .toBeInstanceOf(Date);
+
+        expect(user.createdAt.getTime())
+            .toBe(createdAt);
+
+        expect(user.updatedAt.getTime())
+            .toBeGreaterThan(updatedAt);
+    });
+
+})