@illustrisinteractive/sentinel-nest 0.0.1

package/models/permissionkey.js

@@ -0,0 +1,31 @@
+'use strict';
+const { Model } = require('sequelize');
+module.exports = (sequelize, DataTypes) => {
+  class PermissionKey extends Model {
+    /**
+     * Helper method for defining associations.
+     * This method is not a part of Sequelize lifecycle.
+     * The `models/index` file will call this method automatically.
+     */
+    static associate(models) {
+      // define association here
+    }
+  }
+  PermissionKey.init(
+    {
+      id: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        primaryKey: true,
+      },
+      resource: DataTypes.STRING,
+      action: DataTypes.STRING,
+      description: DataTypes.STRING,
+    },
+    {
+      sequelize,
+      modelName: 'PermissionKey',
+    },
+  );
+  return PermissionKey;
+};

package/models/role.js

@@ -0,0 +1,23 @@
+'use strict';
+const {
+  Model
+} = require('sequelize');
+module.exports = (sequelize, DataTypes) => {
+  class Role extends Model {
+    /**
+     * Helper method for defining associations.
+     * This method is not a part of Sequelize lifecycle.
+     * The `models/index` file will call this method automatically.
+     */
+    static associate(models) {
+      // define association here
+    }
+  }
+  Role.init({
+    name: DataTypes.STRING
+  }, {
+    sequelize,
+    modelName: 'Role',
+  });
+  return Role;
+};

package/models/rolehaspermission.js

@@ -0,0 +1,43 @@
+'use strict';
+const { Model } = require('sequelize');
+module.exports = (sequelize, DataTypes) => {
+  class RoleHasPermission extends Model {
+    /**
+     * Helper method for defining associations.
+     * This method is not a part of Sequelize lifecycle.
+     * The `models/index` file will call this method automatically.
+     */
+    static associate(models) {
+      // define association here
+    }
+  }
+  RoleHasPermission.init(
+    {
+      role: {
+        type: DataTypes.INTEGER,
+        references: {
+          model: {
+            tableName: 'Roles',
+          },
+          key: 'id',
+        },
+        allowNull: false,
+      },
+      permission: {
+        type: DataTypes.INTEGER,
+        references: {
+          model: {
+            tableName: 'PermissionKeys',
+          },
+          key: 'id',
+        },
+        allowNull: false,
+      },
+    },
+    {
+      sequelize,
+      modelName: 'RoleHasPermission',
+    },
+  );
+  return RoleHasPermission;
+};

package/nest-cli.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "@nestjs/schematics",
+  "sourceRoot": "src",
+  "compilerOptions": {
+    "deleteOutDir": true
+  }
+}

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@illustrisinteractive/sentinel-nest",
+  "version": "0.0.1",
+  "description": "",
+  "author": "John Dela Vega <john@luminotion.com>",
+  "license": "MIT",
+  "scripts": {
+    "build-models": "tsc -p src/models/tsconfig.json && tsc-alias -p src/models/tsconfig.json",
+    "build-bin": "tsc -p src/bin/tsconfig.json && tsc-alias -p src/bin/tsconfig.json",
+    "build-module": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json ",
+    "clean": "rimraf dist/",
+    "build": "npm run clean && npm run build-bin && npm run build-module"
+  },
+  "main": "dist/src/main",
+  "rimraf": "./node_modules/rimraf/bin.js",
+  "bin": {
+    "sentinel": "dist/bin/sentinel.js"
+  },
+  "old_scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json"
+  },
+  "peerDependencies": {
+    "@nestjs/core": "^11.0.1"
+  },
+  "dependencies": {
+    "@casl/ability": "^6.8.0",
+    "@clack/prompts": "^1.0.1",
+    "@grpc/grpc-js": "^1.14.3",
+    "@nestjs/common": "^11.0.1",
+    "@nestjs/config": "^4.0.3",
+    "@nestjs/jwt": "^11.0.2",
+    "@nestjs/platform-express": "^11.0.1",
+    "@nestjs/sequelize": "^11.0.1",
+    "@prisma/adapter-pg": "^7.4.1",
+    "@prisma/client": "^7.4.1",
+    "commander": "^14.0.3",
+    "mysql2": "^3.18.0",
+    "pg": "^8.18.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "sequelize": "^6.37.7",
+    "sequelize-typescript": "^2.1.6",
+    "ts-morph": "^27.0.2",
+    "umzug": "^3.8.2"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@eslint/js": "^9.18.0",
+    "@nestjs/cli": "^11.0.0",
+    "@nestjs/schematics": "^11.0.0",
+    "@nestjs/testing": "^11.0.1",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.10.7",
+    "@types/sequelize": "^4.28.20",
+    "@types/supertest": "^6.0.2",
+    "eslint": "^9.18.0",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.2.2",
+    "globals": "^16.0.0",
+    "jest": "^30.0.0",
+    "prettier": "^3.4.2",
+    "prisma": "^7.4.1",
+    "rimraf": "^6.1.3",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.2.5",
+    "ts-loader": "^9.5.2",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.16",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.20.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/prisma/migrations/20260227023704_init/migration.sql

@@ -0,0 +1,74 @@
+-- CreateTable
+CREATE TABLE "ModelHasRoles" (
+    "id" SERIAL NOT NULL,
+    "role" INTEGER NOT NULL,
+    "model" INTEGER NOT NULL,
+    "createdAt" TIMESTAMPTZ(6) NOT NULL,
+    "updatedAt" TIMESTAMPTZ(6) NOT NULL,
+
+    CONSTRAINT "ModelHasRoles_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "PermissionKeys" (
+    "id" VARCHAR(255) NOT NULL,
+    "resource" VARCHAR(255),
+    "action" VARCHAR(255),
+    "createdAt" TIMESTAMPTZ(6) NOT NULL,
+    "updatedAt" TIMESTAMPTZ(6) NOT NULL,
+    "description" VARCHAR(255),
+
+    CONSTRAINT "PermissionKeys_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "RoleHasPermissions" (
+    "id" SERIAL NOT NULL,
+    "role" INTEGER NOT NULL,
+    "permission" VARCHAR(255) NOT NULL,
+    "createdAt" TIMESTAMPTZ(6) NOT NULL,
+    "updatedAt" TIMESTAMPTZ(6) NOT NULL,
+
+    CONSTRAINT "RoleHasPermissions_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "Roles" (
+    "id" SERIAL NOT NULL,
+    "name" VARCHAR(255),
+    "createdAt" TIMESTAMPTZ(6) NOT NULL,
+    "updatedAt" TIMESTAMPTZ(6) NOT NULL,
+
+    CONSTRAINT "Roles_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "SequelizeMeta" (
+    "name" VARCHAR(255) NOT NULL,
+
+    CONSTRAINT "SequelizeMeta_pkey" PRIMARY KEY ("name")
+);
+
+-- CreateTable
+CREATE TABLE "Users" (
+    "id" INTEGER NOT NULL,
+    "firstName" VARCHAR(255),
+    "lastName" VARCHAR(255),
+    "isActive" BOOLEAN DEFAULT true,
+    "createdAt" TIMESTAMPTZ(6) NOT NULL,
+    "updatedAt" TIMESTAMPTZ(6) NOT NULL,
+
+    CONSTRAINT "Users_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "ModelHasRoles" ADD CONSTRAINT "ModelHasRoles_model_fkey" FOREIGN KEY ("model") REFERENCES "Users"("id") ON DELETE NO ACTION ON UPDATE NO ACTION;
+
+-- AddForeignKey
+ALTER TABLE "ModelHasRoles" ADD CONSTRAINT "ModelHasRoles_role_fkey" FOREIGN KEY ("role") REFERENCES "Roles"("id") ON DELETE NO ACTION ON UPDATE NO ACTION;
+
+-- AddForeignKey
+ALTER TABLE "RoleHasPermissions" ADD CONSTRAINT "RoleHasPermissions_permission_fkey" FOREIGN KEY ("permission") REFERENCES "PermissionKeys"("id") ON DELETE NO ACTION ON UPDATE NO ACTION;
+
+-- AddForeignKey
+ALTER TABLE "RoleHasPermissions" ADD CONSTRAINT "RoleHasPermissions_role_fkey" FOREIGN KEY ("role") REFERENCES "Roles"("id") ON DELETE NO ACTION ON UPDATE NO ACTION;

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"

package/prisma/schema.prisma

@@ -0,0 +1,62 @@
+generator client {
+  provider = "prisma-client"
+  output   = "../src/generated/prisma"
+  moduleFormat = "cjs"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model ModelHasRoles {
+  id        Int      @id @default(autoincrement())
+  role      Int
+  model     Int
+  createdAt DateTime @db.Timestamptz(6)
+  updatedAt DateTime @db.Timestamptz(6)
+  Users     Users    @relation(fields: [model], references: [id], onDelete: NoAction, onUpdate: NoAction)
+  Roles     Roles    @relation(fields: [role], references: [id], onDelete: NoAction, onUpdate: NoAction)
+}
+
+model PermissionKeys {
+  id                 String               @id @db.VarChar(255)
+  resource           String?              @db.VarChar(255)
+  action             String?              @db.VarChar(255)
+  createdAt          DateTime             @db.Timestamptz(6)
+  updatedAt          DateTime             @db.Timestamptz(6)
+  description        String?              @db.VarChar(255)
+  RoleHasPermissions RoleHasPermissions[]
+}
+
+model RoleHasPermissions {
+  id             Int            @id @default(autoincrement())
+  role           Int
+  permission     String         @db.VarChar(255)
+  createdAt      DateTime       @db.Timestamptz(6)
+  updatedAt      DateTime       @db.Timestamptz(6)
+  PermissionKeys PermissionKeys @relation(fields: [permission], references: [id], onDelete: NoAction, onUpdate: NoAction)
+  Roles          Roles          @relation(fields: [role], references: [id], onDelete: NoAction, onUpdate: NoAction)
+}
+
+model Roles {
+  id                 Int                  @id @default(autoincrement())
+  name               String?              @db.VarChar(255)
+  createdAt          DateTime             @db.Timestamptz(6)
+  updatedAt          DateTime             @db.Timestamptz(6)
+  ModelHasRoles      ModelHasRoles[]
+  RoleHasPermissions RoleHasPermissions[]
+}
+
+model SequelizeMeta {
+  name String @id @db.VarChar(255)
+}
+
+model Users {
+  id            Int             @id
+  firstName     String?         @db.VarChar(255)
+  lastName      String?         @db.VarChar(255)
+  isActive      Boolean?        @default(true)
+  createdAt     DateTime        @db.Timestamptz(6)
+  updatedAt     DateTime        @db.Timestamptz(6)
+  ModelHasRoles ModelHasRoles[]
+}

package/prisma.config.ts

@@ -0,0 +1,14 @@
+// This file was generated by Prisma, and assumes you have installed the following:
+// npm install --save-dev prisma dotenv
+import 'dotenv/config';
+import { defineConfig } from 'prisma/config';
+
+export default defineConfig({
+  schema: 'prisma/schema.prisma',
+  migrations: {
+    path: 'prisma/migrations',
+  },
+  datasource: {
+    url: `postgres://${process.env.SENTINEL_DB_USER}:${process.env.SENTINEL_DB_PASS}@${process.env.SENTINEL_DB_HOST}:${process.env.SENTINEL_DB_PORT}/${process.env.SENTINEL_DB_DATABASE}`,
+  },
+});

package/src/bin/commit.ts

@@ -0,0 +1,186 @@
+import { confirm, intro, log } from '@clack/prompts';
+import { SecuredResource } from '@models/SecuredResource';
+import { exec } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { exit } from 'process';
+import { Sequelize } from 'sequelize-typescript';
+import { PermissionKey } from '@models/sequelize/PermissionKey';
+
+export const commit = async (envFrom: string, skipPrompts = false) => {
+  intro('Sentinel CLI');
+  log.info('Commit - Prepare your Secured Resources for persistence.');
+
+  if (envFrom) {
+    try {
+      process.loadEnvFile(envFrom);
+    } catch (error) {
+      log.error(
+        `Sentinel CLI failed to commit your Secured Resources during ENV file loading. ${error}`,
+      );
+      exit(-1);
+    }
+  }
+
+  if (!fs.existsSync(process.cwd() + '\\src\\sentinel\\sentinel.config.json')) {
+    log.error(
+      `"sentinel.config.json" was not found in (${process.cwd() + '\\src\\sentinel'}). Have you initialized Sentinel using "npx sentinel init"?`,
+    );
+  }
+  try {
+    await import(
+      'file://' + process.cwd() + '\\src\\sentinel\\sentinel.config.json',
+      {
+        with: { type: 'json' },
+      }
+    );
+  } catch (error) {
+    console.log(error);
+    exit(-1);
+  }
+
+  if (!fs.existsSync('src\\sentinel\\resources')) {
+    log.error(
+      `Resources folder not found in ${process.cwd() + '\\src\\sentinel\\resources'}. Have you created any Secured Resources with "npx sentinel resource <name>"?`,
+    );
+    // exit(-1);
+  }
+
+  await new Promise((resolve) => {
+    exec(`tsc -p ${'src\\sentinel\\resources'}\\tsconfig.json`, () => {
+      resolve(undefined);
+    });
+  });
+
+  const compilePath =
+    process.cwd() + `${'\\src\\sentinel\\resources'}\\.sentinel`;
+  const resourcesToImport = fs
+    .readdirSync(compilePath)
+    .filter((file) => path.extname(file) == '.js');
+
+  log.info(
+    `Found ${resourcesToImport.length} files in Secured Resources directory.`,
+  );
+
+  const resources: SecuredResource[] = [];
+  const promises: Promise<any>[] = [];
+  resourcesToImport.forEach((_res) => {
+    promises.push(
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises, no-async-promise-executor
+      new Promise(async (resolve) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+        const res = (await import(`file://${compilePath}/${_res}`)).default[
+          _res.split('.')[0]
+        ];
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        resources.push(res);
+        resolve(undefined);
+      }),
+    );
+  });
+
+  await Promise.all(promises);
+
+  log.info('Secured Resources Graph');
+  resources.forEach((res) => {
+    log.step(res.name);
+    let message = '';
+    if (res.actions) {
+      Object.keys(res.actions).forEach((_key) => {
+        const action = res.actions[_key];
+        message += `-> ${_key} - ${action.description || 'No description.'}\n`;
+      });
+    }
+    log.message(message);
+  });
+
+  if (!skipPrompts) {
+    const ok = await confirm({
+      message: `Are you sure you want to commit ${resources.length} Secured Resources to your database? Please review the graph above if all Actions were successfully read.`,
+    });
+
+    if (!ok) {
+      log.error('Commit was cancelled.');
+      exit(-1);
+    }
+  }
+
+  try {
+    const opts = {
+      SENTINEL_DB_HOST: process.env.SENTINEL_DB_HOST,
+      SENTINEL_DB_USER: process.env.SENTINEL_DB_USER,
+      SENTINEL_DB_PASS: process.env.SENTINEL_DB_PASS,
+      SENTINEL_DB_PORT: process.env.SENTINEL_DB_PORT as unknown as number,
+      SENTINEL_DB_DATABASE: process.env.SENTINEL_DB_DATABASE,
+    };
+
+    const missingOpts = Object.keys(opts).filter((key) => {
+      return opts[key] === undefined;
+    });
+
+    if (missingOpts.length != 0) {
+      log.error(
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        `Sentinel CLI failed to commit your Secured Resources due to missing environment variables: ${missingOpts}.`,
+      );
+      log.message(
+        'If these variables are defined in a file, run `npx sentinel init --env-from="<path>"` instead.',
+      );
+      exit(-1);
+    }
+
+    const sequelize = new Sequelize({
+      dialect: 'postgres',
+      host: opts.SENTINEL_DB_HOST,
+      username: opts.SENTINEL_DB_USER,
+      password: opts.SENTINEL_DB_PASS,
+      port: opts.SENTINEL_DB_PORT,
+      database: opts.SENTINEL_DB_DATABASE,
+      models: [PermissionKey],
+    });
+
+    try {
+      await sequelize.authenticate();
+    } catch (error) {
+      console.log(error);
+      log.error(
+        'Sentinel CLI cannot connect to your database. Initialization failed.',
+      );
+
+      exit(-1);
+    }
+
+    log.success('Successfully connected to your database.');
+
+    const keysToSeed: Promise<PermissionKey>[] = [];
+
+    for (const res of resources) {
+      Object.keys(res.actions).forEach((_key) => {
+        const action = res.actions[_key];
+        keysToSeed.push(
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+          PermissionKey.upsert({
+            id: `${res.name.toLowerCase()}.${_key.toLowerCase()}`,
+            resource: res.name,
+            action: _key,
+            description: action.description || '',
+          })[0],
+        );
+      });
+    }
+
+    await Promise.all(keysToSeed);
+
+    log.success(
+      'Successfully commited all Secured Resources and their actions',
+    );
+  } catch (error) {
+    console.log(error);
+  }
+
+  // const res = (
+  //   await import(`file://${process.cwd()}/.sentinel/TestResource.js`)
+  // ).default['TestResource'];
+  // console.log(new res());
+};