• Index
• Search by APIs
• Search by Words
• Project Search

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• feathers-casl-master
  • .codeclimate.yml
  • .github
    • stale.yml
    • issue_template.md
    • workflows
      • node.js.yml
  • .eslintignore
  • .mocharc.js
  • netlify.toml
  • .nvmrc
  • LICENSE
  • test
    • utils
      • getFieldsForConditions.test.ts
      • convertRuleToQuery.test.ts
      • hasRestrictingFields.test.ts
      • checkCan.test.ts
      • getModelName.test.ts
      • simplifyQuery.test.ts
      • getMinimalFields.test.ts
      • getDefaultModelName.test.ts
    • hooks
      • checkBasicPermission.test.ts
      • authorize.users.test.ts
      • authorize
        • authorize.options.test.ts
        • authorize.relations.test.ts
        • authorize.general.test.ts
        • adapters
          • nedb.test.ts
          • sequelize.test.ts
          • mongodb.test.ts
          • feathers-memory.test.ts
          • knex.test.ts
          • makeTests
            • remove.ts
            • create-multi.ts
            • index.ts
            • patch.ts
            • update.ts
            • update-data.ts
            • create.ts
            • patch-multi.ts
            • remove-multi.ts
            • patch-data.ts
            • get.ts
            • find.ts
          • mongoose.test.ts
          • objection.test.ts
    • channels
      • .mockServer
        • index.ts
        • config
          • default.js
      • receive
        • channels.receive.test.ts
        • mockChannels.receive.ts
        • mockServices.receive.ts
      • withAvailableFields
        • channels.availableFields.test.ts
        • mockChannels.availableFields.ts
        • mockServices.availableFields.ts
      • custom-actions
        • mockChannels.custom-actions.ts
        • mockServices.custom-actions.ts
        • channels.custom-actions.test.ts
      • channels.utils.test.ts
      • defaultSettings
        • mockChannels.default.ts
        • channels.default.test.ts
        • mockServices.default.ts
    • index.test.ts
    • makeAbilityFromRules.test.ts
    • app
      • options.test.ts
  • lib
    • utils
      • getAvailableFields.ts
      • checkCan.ts
      • mergeQueryFromAbility.ts
      • couldHaveRestrictingFields.ts
      • getDefaultModelName.ts
      • getModelName.ts
      • getMinimalFields.ts
      • checkBasicPermission.ts
      • getFieldsForConditions.ts
      • simplifyQuery.ts
      • convertRuleToQuery.ts
      • hasRestrictingFields.ts
      • hasRestrictingConditions.ts
    • makeAbilityFromRules.ts
    • hooks
      • index.ts
      • common.ts
      • authorize
        • authorize.hook.before.ts
        • authorize.hook.utils.ts
        • authorize.hook.ts
        • authorize.hook.after.ts
      • checkBasicPermission.hook.ts
    • index.ts
    • channels
      • getChannelsWithReadAbility.ts
      • index.ts
      • channels.utils.ts
    • initialize.ts
    • types.ts
  • .eslintrc
  • README.md
  • package.json
  • tsconfig.test.json
  • tsconfig.json
  • .gitignore
  • docs
    • getting-started.md
    • hooks.md
    • utils.md
    • index.md
    • client-side.md
    • channels.md
    • .vuepress
      • style
        • index.scss
      • config.ts
      • public
        • img
    • cookbook.md
    • gotchas.md
  • .nycrc.json
  • .vscode
    • settings.json
    • launch.json

import { Sequelize, DataTypes, Op } from "sequelize";
import makeTests from "./makeTests";
import { Service } from "feathers-sequelize";
import { getItems } from "feathers-hooks-common";
import path from "path";
import { ServiceCaslOptions } from "../../../../lib/types";
import { HookContext } from "@feathersjs/feathers";

const sequelize = new Sequelize("sequelize", "", "", {
  dialect: "sqlite",
  storage: path.join(__dirname, "../../../.data/db.sqlite"),
  logging: false
});

declare module "@feathersjs/adapter-commons" {
  interface ServiceOptions {
    casl: ServiceCaslOptions
  }
}

const Model = sequelize.define("tests", {
  userId: {
    type: DataTypes.INTEGER
  },
  hi: {
    type: DataTypes.STRING
  },
  test: {
    type: DataTypes.BOOLEAN
  },
  published: {
    type: DataTypes.BOOLEAN
  },
  supersecret: {
    type: DataTypes.BOOLEAN
  },
  hidden: {
    type: DataTypes.BOOLEAN
  }
}, {
  timestamps: false
});

declare module "feathers-sequelize" {
  interface SequelizeServiceOptions {
    operators: any
  }
}

const makeService = () => {
  return new Service({
    Model,
    multi: true,
    operators: {
      $not: Op.not
    },
    whitelist: ["$not"],
    casl: {
      availableFields: [
        "id", 
        "userId", 
        "hi", 
        "test", 
        "published",
        "supersecret", 
        "hidden"
      ]
    },
    paginate: {
      default: 10,
      max: 50
    }
  });
};

const afterHooks = [
  (context: HookContext) => {
    const { Model } = context.service;
    const fields = Model.fieldRawAttributesMap;
    let items = getItems(context);
    items = (Array.isArray(items)) ? items : [items];

    items.forEach(item => {
      const keys = Object.keys(item);
      keys.forEach(key => {
        const field = fields[key];
        if (item[key] === null) {
          delete item[key];
          return;
        }
        // @ts-ignore
        if (field.type instanceof DataTypes.BOOLEAN) {
          item[key] = !!item[key];
        }
      });
    });
  }
];

makeTests(
  "feathers-sequelize", 
  makeService, 
  async () => { 
    await Model.sync({ force: true });
  },
  { adapter: "feathers-sequelize" },
  afterHooks
);