typeorm-hasura 0.0.1

package/.env.example

@@ -0,0 +1,9 @@
+# use 
+DB_URL=postgres://username:password@localhost:5432/database_name
+# or
+DB_HOST=localhost
+DB_PORT=5432
+DB_USERNAME=postgres
+DB_PASSWORD=password
+DB_NAME=database_name
+DB_SCHEMA=public

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Utyfua
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dev-playground/UserRole.ts

@@ -0,0 +1,5 @@
+export enum UserRole {
+    admin = 'admin',
+    user = 'user',
+    editor = 'editor',
+}

package/dev-playground/action/currencyConverter.ts

@@ -0,0 +1,60 @@
+// based on https://hasura.io/docs/latest/actions/quickstart/
+import gql from 'graphql-tag';
+import { ActionBuilder } from '../../src/builders';
+import { UserRole } from '../UserRole';
+
+export const currencyConverterAction = ActionBuilder.buildV1({
+    comment: "Convert currency with real-time exchange rates.",
+    handler: "https://api.exchangerate.host/convert",
+    definitionType: gql`
+        type Query {
+            currencyConverter(CurrencyInfo: ConvertCurrencyInputParams!): ConvertedCurrency
+        }
+
+        input ConvertCurrencyInputParams {
+            from: String
+            to: String
+            amt: Int
+        }
+            
+        type ConvertedCurrency {
+            date: String
+            info: ConvertedCurrencyInfo
+            query: ConvertedCurrencyQuery
+            result: Float
+            success: Boolean
+        }
+            
+        type ConvertedCurrencyInfo {
+            rate: Float
+        }
+            
+        type ConvertedCurrencyQuery {
+            amount: Int
+            from: String
+            to: String
+        }
+    `,
+    permissions: [
+        { role: UserRole.user },
+    ],
+    nativeDefinition: {
+        request_transform: {
+            method: "GET",
+            query_params: {
+                "amount": "{{$body.input.CurrencyInfo.amt}}",
+                "from": "{{$body.input.CurrencyInfo.from}}",
+                "to": "{{$body.input.CurrencyInfo.to}}"
+            },
+            request_headers: {
+                "add_headers": {},
+                "remove_headers": [
+                    "content-type"
+                ]
+            },
+            template_engine: "Kriti",
+            // @ts-ignore types are wrong!
+            version: 2,
+        },
+    },
+})

package/dev-playground/data-source.ts

@@ -0,0 +1,21 @@
+import "reflect-metadata"
+import { DataSource } from "typeorm"
+import * as entities from "./entity"
+
+const { DB_URL, DB_HOST, DB_PORT, DB_USERNAME, DB_PASSWORD, DB_NAME, DB_SCHEMA } = process.env
+
+export const AppDataSource = new DataSource({
+    type: "postgres",
+    url: DB_URL,
+    host: DB_HOST,
+    port: Number(DB_PORT),
+    username: DB_USERNAME,
+    password: DB_PASSWORD,
+    database: DB_NAME,
+    schema: DB_SCHEMA,
+    synchronize: false,
+    logging: false,
+    entities: Object.values(entities),
+    migrations: ['./test/migration/*.ts'],
+    subscribers: [],
+})

package/dev-playground/entity/Org.ts

@@ -0,0 +1,52 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    OneToMany,
+    BaseEntity
+} from 'typeorm';
+import { HasuraEntity, HasuraColumn } from '../../src';
+import { Product } from './Product';
+import { User } from './User';
+import { UserRole } from '../UserRole';
+
+
+@Entity({ schema: 'public', name: 'Org' })
+@HasuraEntity<Org>({
+    customName: 'Org',
+    permissions: {
+        [UserRole.user]: {
+            where: {
+                users: {
+                    id: 'X-Hasura-User-Id'
+                }
+            },
+            select: true,
+            update: true,
+        }
+    },
+})
+export class Org extends BaseEntity {
+    @PrimaryGeneratedColumn('uuid')
+    @HasuraColumn({
+        permissions: {
+            [UserRole.user]: ['select']
+        }
+    })
+    id!: string;
+
+    @Column({ type: 'text', nullable: true })
+    @HasuraColumn({
+        // customName: 'myOrgName',
+        permissions: {
+            [UserRole.user]: ['select', 'update']
+        }
+    })
+    name!: string;
+
+    @OneToMany(() => User, (user) => user.org)
+    users!: User[];
+
+    @OneToMany(() => Product, (product) => product.org)
+    products!: Product[];
+}

package/dev-playground/entity/Product.ts

@@ -0,0 +1,74 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column, ManyToOne,
+    JoinColumn,
+    BaseEntity
+} from 'typeorm';
+import { HasuraColumn, HasuraEntity } from '../../src';
+import { User } from './User';
+import { Org } from "./Org";
+import { UserRole } from '../UserRole';
+
+
+@Entity({ schema: 'public', name: 'Product' })
+@HasuraEntity<Product>({
+    customName: 'Product',
+    permissions: {
+        [UserRole.user]: {
+            where: [
+                { userId: 'X-Hasura-User-Id' },
+                {
+                    org: {
+                        users: {
+                            id: 'X-Hasura-User-Id'
+                        }
+                    }
+                }
+            ],
+            select: true,
+            update: true,
+        }
+    }
+})
+export class Product extends BaseEntity {
+    @PrimaryGeneratedColumn('uuid')
+    @HasuraColumn({
+        permissions: {
+            [UserRole.user]: ['select']
+        }
+    })
+    id!: string;
+
+    @Column({ type: 'text', nullable: true })
+    @HasuraColumn({
+        permissions: {
+            [UserRole.user]: ['select', 'update']
+        }
+    })
+    name!: string;
+
+    @Column({ name: 'orgId', type: 'uuid', nullable: true })
+    @HasuraColumn({
+        permissions: {
+            [UserRole.user]: ['select']
+        }
+    })
+    orgId!: string;
+
+    @ManyToOne(() => Org, (org) => org.products)
+    @JoinColumn({ name: 'orgId' })
+    org!: Org;
+
+    @Column({ name: 'userId', type: 'uuid', nullable: true })
+    @HasuraColumn({
+        permissions: {
+            [UserRole.user]: ['select']
+        }
+    })
+    userId!: string;
+
+    @ManyToOne(() => User, (user) => user.products)
+    @JoinColumn({ name: 'userId' })
+    user!: User;
+}

package/dev-playground/entity/User.ts

@@ -0,0 +1,51 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    OneToMany,
+    ManyToOne,
+    JoinColumn,
+    BaseEntity,
+} from 'typeorm';
+import { HasuraColumn, HasuraEntity } from '../../src';
+import { Org } from './Org';
+import { Product } from './Product';
+import { UserRole } from '../UserRole';
+
+
+@Entity({ schema: 'public', name: 'User' })
+@HasuraEntity<User>({
+    customName: 'User',
+    permissions: {
+        [UserRole.user]: {
+            select: true,
+            update: {
+                where: {
+                    id: 'X-Hasura-User-Id'
+                }
+            },
+        }
+    }
+})
+export class User extends BaseEntity {
+    @PrimaryGeneratedColumn('uuid')
+    @HasuraColumn({ permissions: { [UserRole.user]: ['select'] } })
+    id!: string;
+
+    @Column({ type: 'text', nullable: true })
+    @HasuraColumn({ permissions: { [UserRole.user]: ['select', 'update'] } })
+    name!: string;
+
+    @Column({ name: 'orgId', type: 'uuid', nullable: true })
+    @HasuraColumn({ permissions: { [UserRole.user]: ['select'] } })
+    orgId!: string;
+
+    @ManyToOne(() => Org, (org) => org.users)
+    @JoinColumn({ name: 'orgId' })
+    org!: Org;
+
+    @OneToMany(() => Product, (product) => product.user)
+    products!: Product[];
+}
+
+

package/dev-playground/entity/index.ts

@@ -0,0 +1,3 @@
+export * from './Org';
+export * from './Product';
+export * from './User';

package/dev-playground/hasura.ts

@@ -0,0 +1,35 @@
+import { MetadataBuilder } from "../src";
+import { currencyConverterAction } from "./action/currencyConverter";
+import { AppDataSource } from "./data-source"
+import { writeFile, mkdir } from "fs/promises"
+
+async function convert() {
+    const metadata = await new MetadataBuilder()
+        .addSource({
+            name: "public",
+            dataSource: AppDataSource,
+            databaseUrl: process.env.HASURA_DATABASE_URL,
+            defaultSelectPermissionLimit: 50,
+        })
+        .addActions([
+            currencyConverterAction,
+        ])
+        .getMetadata()
+
+    await mkdir("tmp/output", { recursive: true })
+        .catch(error => console.log(error));
+    await writeFile(
+        `tmp/output/metadata-${Date.now()}.json`,
+        JSON.stringify(metadata, null, 2)
+    )
+    AppDataSource.close();
+    console.log("Done and done");
+}
+
+AppDataSource.initialize()
+    .then(convert)
+    .catch(error => console.log(error))
+
+if (process.env.DEV_KEEP_ALIVE) {
+    setInterval(() => 1, 1000 * 60 * 60)
+}

package/dev-playground/index.ts

@@ -0,0 +1,43 @@
+import { AppDataSource } from "./data-source";
+import { User, Org, Product } from "./entity";
+
+async function main() {
+    try {
+        await AppDataSource.initialize();
+
+        console.log("Inserting a new organization into the database...");
+        const org = new Org();
+        org.name = "Example Organization";
+        await org.save();
+        console.log("Saved a new organization with id: " + org.id);
+
+        console.log("Inserting a new user into the database...");
+        const user = new User();
+        user.name = "John Doe";
+        user.orgId = org.id;
+        await user.save();
+        console.log("Saved a new user with id: " + user.id);
+
+        console.log("Inserting a new product into the database...");
+        const product = new Product();
+        product.name = "Example Product";
+        product.orgId = org.id;
+        product.userId = user.id;
+        await product.save();
+        console.log("Saved a new product with id: " + product.id);
+
+        console.log("Loading organizations, users, and products from the database...");
+        const organizations = await Org.find();
+        const users = await User.find();
+        const products = await Product.find();
+        console.log("Loaded organizations: ", organizations);
+        console.log("Loaded users: ", users);
+        console.log("Loaded products: ", products);
+
+        console.log("Here you can set up and run express / fastify / any other framework.");
+    } catch (error) {
+        console.log(error);
+    }
+}
+
+main();

package/dev-playground/migration/1679166386871-next.ts

@@ -0,0 +1,29 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+const schema = process.env.DB_SCHEMA || "${schema}";
+
+if (schema.includes('"') || schema.includes("'") || schema.includes("\\")) {
+    throw new Error("Invalid schema name");
+}
+
+export class next1679166386871 implements MigrationInterface {
+    name = 'next1679166386871'
+
+    async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "${schema}"."User" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" text, "orgId" uuid, CONSTRAINT "PK_9862f679340fb2388436a5ab3e4" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TABLE "${schema}"."Product" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" text, "orgId" uuid, "userId" uuid, CONSTRAINT "PK_9fc040db7872192bbc26c515710" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`CREATE TABLE "${schema}"."Org" ("id" uuid NOT NULL DEFAULT uuid_generate_v4(), "name" text, CONSTRAINT "PK_cca1cae86d5c2eefca56675b245" PRIMARY KEY ("id"))`);
+        await queryRunner.query(`ALTER TABLE "${schema}"."User" ADD CONSTRAINT "FK_da2f97fadc32136438de8d6a7a7" FOREIGN KEY ("orgId") REFERENCES "${schema}"."Org"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "${schema}"."Product" ADD CONSTRAINT "FK_0426b5b66a3ad86d93237917bbf" FOREIGN KEY ("orgId") REFERENCES "${schema}"."Org"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "${schema}"."Product" ADD CONSTRAINT "FK_de75905c3b4987f4b5bb1472644" FOREIGN KEY ("userId") REFERENCES "${schema}"."User"("id") ON DELETE NO ACTION ON UPDATE NO ACTION`);
+    }
+
+    async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "${schema}"."Product" DROP CONSTRAINT "FK_de75905c3b4987f4b5bb1472644"`);
+        await queryRunner.query(`ALTER TABLE "${schema}"."Product" DROP CONSTRAINT "FK_0426b5b66a3ad86d93237917bbf"`);
+        await queryRunner.query(`ALTER TABLE "${schema}"."User" DROP CONSTRAINT "FK_da2f97fadc32136438de8d6a7a7"`);
+        await queryRunner.query(`DROP TABLE "${schema}"."Org"`);
+        await queryRunner.query(`DROP TABLE "${schema}"."Product"`);
+        await queryRunner.query(`DROP TABLE "${schema}"."User"`);
+    }
+}

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testPathIgnorePatterns: ['/node_modules/'],
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "typeorm-hasura",
+  "version": "0.0.1",
+  "description": "",
+  "keywords": [
+    "hasura",
+    "typeorm"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/esm/index.d.ts",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/utyfua/typeorm-hasura.git"
+  },
+  "bugs": {
+    "url": "https://github.com/utyfua/typeorm-hasura/issues"
+  },
+  "scripts": {
+    "clean": "rimraf dist/*",
+    "prebuild": "run-s clean",
+    "build": "run-s build:tsc build:rollup",
+    "build:tsc": "tsc --module commonjs",
+    "build:rollup": "rollup -c ",
+    "typeorm": "typeorm-ts-node-esm",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "play:gen": "npx env-cmd npx typeorm-ts-node-esm migration:generate ./dev-playground/migration/next -d ./dev-playground/data-source",
+    "play:up": "npx env-cmd npx typeorm-ts-node-esm  migration:run -d ./dev-playground/data-source",
+    "play:down": "npx env-cmd npx typeorm-ts-node-esm  migration:revert -d ./dev-playground/data-source",
+    "play:start": "npx env-cmd ts-node dev-playground/index.ts",
+    "play:run": "npx env-cmd ts-node dev-playground/hasura.ts"
+  },
+  "author": {
+    "name": "Utyfua",
+    "email": "utyfua@gmail.com"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "graphql": "^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0",
+    "graphql-tag": "^2.0.0",
+    "lodash.snakecase": "^4.1.1"
+  },
+  "peerDependencies": {
+    "graphql": "^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0",
+    "graphql-tag": "^2.0.0",
+    "typeorm": "^0.3.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-babel": "^6.0.3",
+    "@rollup/plugin-commonjs": "^24.0.1",
+    "@rollup/plugin-node-resolve": "^15.0.2",
+    "@rollup/plugin-typescript": "^11.1.0",
+    "@types/jest": "^29.5.0",
+    "@types/lodash.snakecase": "^4.1.7",
+    "@types/node": "^18.14.0",
+    "env-cmd": "^10.1.0",
+    "hasura-metadata-types": "^2.22.1",
+    "jest": "^29.5.0",
+    "npm-run-all": "^4.1.5",
+    "pg": "^8.10.0",
+    "reflect-metadata": "^0.1.13",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.79.1",
+    "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.1",
+    "typeorm": "^0.3.12"
+  }
+}

package/random-notes.md

@@ -0,0 +1,8 @@
+
+```
+CREATE EXTENSION IF NOT EXISTS pgcrypto SCHEMA "hasura_zero"
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp" SCHEMA "hasura_zero"
+
+SET search_path TO public,"hasura_zero"
+set search_path = public,"hasura_zero";
+```

package/rollup.config.mjs

@@ -0,0 +1,56 @@
+
+import nodeResolve from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import typescript from '@rollup/plugin-typescript';
+import { babel } from '@rollup/plugin-babel';
+
+import pkg from './package.json' assert { type: 'json' };
+
+const banner = `
+/*!
+ * ${pkg.name} v${pkg.version} by ${pkg.author}
+ * ${"homepage" in pkg ? pkg.homepage : `https://github.com/${pkg.repository}`}
+ * @license ${pkg.license}
+ */
+`.trim()
+
+const defaultExportOutro = `
+  module.exports = exports.default || {}
+  Object.entries(exports).forEach(([key, value]) => { module.exports[key] = value })
+`
+
+export default {
+  input: 'src/index.ts',
+  output: [
+    {
+      file: pkg.main,
+      format: 'cjs',
+      sourcemap: true,
+      exports: 'named',
+      outro: defaultExportOutro,
+      banner
+    },
+    {
+      file: pkg.module,
+      format: 'es',
+      sourcemap: true,
+      exports: 'named',
+      banner
+    }
+  ],
+  external: [
+    ...Object.keys(pkg.dependencies || {}),
+    ...Object.keys(pkg.peerDependencies || {}),
+  ],
+  plugins: [
+    nodeResolve(),
+    babel({
+      exclude: 'node_modules/**',
+    }),
+    commonjs(),
+    // Compile TypeScript files
+    typescript({
+      declaration: true,
+    }),
+  ],
+};

package/src/builders/Action.ts

@@ -0,0 +1,27 @@
+import type * as Hasura from "hasura-metadata-types";
+import { getGraphQLDefinitions } from "../mappers/graphql";
+import { ActionBuildResult, ActionCustomMetadataV1 } from "../types";
+
+export class ActionBuilder {
+    static buildV1(customMetadata: ActionCustomMetadataV1): ActionBuildResult {
+        const defs = getGraphQLDefinitions(customMetadata.definitionType);
+        if (defs.baseActions.length !== 1)
+            throw new Error(`Expected exactly one base action, got ${defs.baseActions.length}`);
+        const [baseAction] = defs.baseActions;
+        const action: Hasura.Action = {
+            name: baseAction.name,
+            comment: customMetadata.comment,
+            permissions: customMetadata.permissions,
+            definition: {
+                ...baseAction.definition,
+                forward_client_headers: customMetadata.forwardClientHeaders || false,
+                handler: customMetadata.handler,
+                ...customMetadata.nativeDefinition,
+            }
+        };
+        return {
+            actions: [action],
+            custom_types: defs.custom_types,
+        };
+    }
+}