@grapadigital/shared-schemas 1.0.180 → 1.0.182

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from './schemas/payment.schema';
 export * from './schemas/profile.schema';
 export * from './schemas/recruitment.schema';
 export * from './schemas/task.schema';
+export * from './schemas/assignment.schema';
 export * from './schemas/token.schema';
 export * from './schemas/webhook.schema';
 export * from './schemas/sale.schema';

package/dist/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./schemas/payment.schema"), exports);
 __exportStar(require("./schemas/profile.schema"), exports);
 __exportStar(require("./schemas/recruitment.schema"), exports);
 __exportStar(require("./schemas/task.schema"), exports);
+__exportStar(require("./schemas/assignment.schema"), exports);
 __exportStar(require("./schemas/token.schema"), exports);
 __exportStar(require("./schemas/webhook.schema"), exports);
 __exportStar(require("./schemas/sale.schema"), exports);

package/dist/schemas/assignment.schema.d.ts

@@ -0,0 +1,87 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import { HydratedDocument, Schema as MongooseSchema, Types } from 'mongoose';
+import { Action } from './action.schema';
+export type AssignmentDocument = HydratedDocument<Assignment>;
+export declare const ASSIGNMENT_TYPE_VALUES: readonly ["report", "curation", "opt-in", "metrics-monitoring", "data-update", "study"];
+export type AssignmentType = (typeof ASSIGNMENT_TYPE_VALUES)[number];
+export declare const ASSIGNMENT_STATUS_VALUES: readonly ["todo", "in-progress", "waiting", "review", "done", "paused", "cancelled", "deleted"];
+export type AssignmentStatus = (typeof ASSIGNMENT_STATUS_VALUES)[number];
+export declare const ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES: readonly ["none", "daily", "weekly", "biweekly", "monthly", "yearly", "weekdays", "custom"];
+export type AssignmentRecurrenceFrequency = (typeof ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES)[number];
+export declare class AssignmentRecurrence {
+    frequency: AssignmentRecurrenceFrequency;
+    interval?: number;
+    byWeekday?: number[];
+    until?: Date;
+    occurrencesCount?: number;
+}
+export declare const AssignmentRecurrenceSchema: MongooseSchema<AssignmentRecurrence, import("mongoose").Model<AssignmentRecurrence, any, any, any, import("mongoose").Document<unknown, any, AssignmentRecurrence, any, {}> & AssignmentRecurrence & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, AssignmentRecurrence, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<AssignmentRecurrence>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<AssignmentRecurrence> & {
+    _id: Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export declare class Assignment {
+    _id?: Types.ObjectId;
+    action: Types.ObjectId | Action;
+    organization: Types.ObjectId;
+    type: AssignmentType;
+    title: string;
+    responsible?: Types.ObjectId;
+    dueDate?: Date | null;
+    status: AssignmentStatus;
+    recurrence?: AssignmentRecurrence;
+    seriesId?: Types.ObjectId;
+    notes?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export declare const AssignmentSchema: MongooseSchema<Assignment, import("mongoose").Model<Assignment, any, any, any, import("mongoose").Document<unknown, any, Assignment, any, {}> & Assignment & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Assignment, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Assignment>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<Assignment> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>;
+export declare const AssignmentModel: import("mongoose").Model<Assignment, {}, {}, {}, import("mongoose").Document<unknown, {}, Assignment, {}, import("mongoose").DefaultSchemaOptions> & Assignment & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, MongooseSchema<Assignment, import("mongoose").Model<Assignment, any, any, any, import("mongoose").Document<unknown, any, Assignment, any, {}> & Assignment & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Assignment, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Assignment>, {}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & import("mongoose").FlatRecord<Assignment> & Required<{
+    _id: Types.ObjectId;
+}> & {
+    __v: number;
+}>>;

package/dist/schemas/assignment.schema.js

@@ -0,0 +1,162 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignmentModel = exports.AssignmentSchema = exports.Assignment = exports.AssignmentRecurrenceSchema = exports.AssignmentRecurrence = exports.ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES = exports.ASSIGNMENT_STATUS_VALUES = exports.ASSIGNMENT_TYPE_VALUES = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+const swagger_1 = require("@nestjs/swagger");
+const mongoose_2 = require("mongoose");
+exports.ASSIGNMENT_TYPE_VALUES = [
+    'report',
+    'curation',
+    'opt-in',
+    'metrics-monitoring',
+    'data-update',
+    'study',
+];
+exports.ASSIGNMENT_STATUS_VALUES = [
+    'todo',
+    'in-progress',
+    'waiting',
+    'review',
+    'done',
+    'paused',
+    'cancelled',
+    'deleted',
+];
+exports.ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES = [
+    'none',
+    'daily',
+    'weekly',
+    'biweekly',
+    'monthly',
+    'yearly',
+    'weekdays',
+    'custom',
+];
+let AssignmentRecurrence = class AssignmentRecurrence {
+};
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: exports.ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES, example: 'monthly' }),
+    (0, mongoose_1.Prop)({
+        type: String,
+        enum: exports.ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES,
+        required: true,
+    }),
+    __metadata("design:type", String)
+], AssignmentRecurrence.prototype, "frequency", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 1, required: false }),
+    (0, mongoose_1.Prop)({ type: Number, required: false }),
+    __metadata("design:type", Number)
+], AssignmentRecurrence.prototype, "interval", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: [1, 3, 5], required: false }),
+    (0, mongoose_1.Prop)({ type: [Number], required: false }),
+    __metadata("design:type", Array)
+], AssignmentRecurrence.prototype, "byWeekday", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '2026-12-31T00:00:00.000Z', required: false }),
+    (0, mongoose_1.Prop)({ type: Date, required: false }),
+    __metadata("design:type", Date)
+], AssignmentRecurrence.prototype, "until", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 12, required: false }),
+    (0, mongoose_1.Prop)({ type: Number, required: false }),
+    __metadata("design:type", Number)
+], AssignmentRecurrence.prototype, "occurrencesCount", void 0);
+AssignmentRecurrence = __decorate([
+    (0, mongoose_1.Schema)({ _id: false })
+], AssignmentRecurrence);
+exports.AssignmentRecurrence = AssignmentRecurrence;
+exports.AssignmentRecurrenceSchema = mongoose_1.SchemaFactory.createForClass(AssignmentRecurrence);
+let Assignment = class Assignment {
+};
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '64bfc3a78d3f1e2a12345670' }),
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, auto: true, required: false }),
+    __metadata("design:type", mongoose_2.Types.ObjectId)
+], Assignment.prototype, "_id", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '64bfc3a78d3f1e2a12345678' }),
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, ref: 'Action', required: true }),
+    __metadata("design:type", Object)
+], Assignment.prototype, "action", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '64bfc3a78d3f1e2a12345679' }),
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, required: true }),
+    __metadata("design:type", mongoose_2.Types.ObjectId)
+], Assignment.prototype, "organization", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: exports.ASSIGNMENT_TYPE_VALUES, example: 'report' }),
+    (0, mongoose_1.Prop)({ type: String, enum: exports.ASSIGNMENT_TYPE_VALUES, required: true }),
+    __metadata("design:type", String)
+], Assignment.prototype, "type", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 'Relatório mensal de performance' }),
+    (0, mongoose_1.Prop)({ type: String, required: true }),
+    __metadata("design:type", String)
+], Assignment.prototype, "title", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '64bfc3a78d3f1e2a1234567a', required: false }),
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, required: false }),
+    __metadata("design:type", mongoose_2.Types.ObjectId)
+], Assignment.prototype, "responsible", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '2026-09-01T00:00:00.000Z', required: false }),
+    (0, mongoose_1.Prop)({ type: Date, required: false, default: null }),
+    __metadata("design:type", Object)
+], Assignment.prototype, "dueDate", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: exports.ASSIGNMENT_STATUS_VALUES, example: 'todo' }),
+    (0, mongoose_1.Prop)({
+        type: String,
+        enum: exports.ASSIGNMENT_STATUS_VALUES,
+        default: 'todo',
+        required: true,
+    }),
+    __metadata("design:type", String)
+], Assignment.prototype, "status", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: () => AssignmentRecurrence, required: false }),
+    (0, mongoose_1.Prop)({ type: exports.AssignmentRecurrenceSchema, required: false }),
+    __metadata("design:type", AssignmentRecurrence)
+], Assignment.prototype, "recurrence", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '64bfc3a78d3f1e2a1234567b', required: false }),
+    (0, mongoose_1.Prop)({ type: mongoose_2.Schema.Types.ObjectId, required: false }),
+    __metadata("design:type", mongoose_2.Types.ObjectId)
+], Assignment.prototype, "seriesId", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 'Aguardando retorno do cliente', required: false }),
+    (0, mongoose_1.Prop)({ type: String, required: false }),
+    __metadata("design:type", String)
+], Assignment.prototype, "notes", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '2026-08-26T15:00:00.000Z' }),
+    (0, mongoose_1.Prop)({ type: Date, default: Date.now, required: false }),
+    __metadata("design:type", Date)
+], Assignment.prototype, "createdAt", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: '2026-08-26T15:00:00.000Z' }),
+    (0, mongoose_1.Prop)({ type: Date, default: Date.now, required: false }),
+    __metadata("design:type", Date)
+], Assignment.prototype, "updatedAt", void 0);
+Assignment = __decorate([
+    (0, mongoose_1.Schema)({ timestamps: true })
+], Assignment);
+exports.Assignment = Assignment;
+exports.AssignmentSchema = mongoose_1.SchemaFactory.createForClass(Assignment);
+exports.AssignmentSchema.index({ action: 1 });
+exports.AssignmentSchema.index({ organization: 1, status: 1 });
+exports.AssignmentSchema.index({ organization: 1, dueDate: 1 });
+exports.AssignmentSchema.index({ seriesId: 1 });
+exports.AssignmentSchema.index({ responsible: 1, dueDate: 1 });
+exports.AssignmentModel = (0, mongoose_2.model)('Assignment', exports.AssignmentSchema);

package/dist/schemas/user.schema.d.ts

@@ -30,7 +30,8 @@ export declare enum OrganizationTeam {
     ADMIN = "admin",
     ARTISTIC = "artistic",
     FINANCIAL = "financial",
-    COMERCIAL = "comercial"
+    COMERCIAL = "comercial",
+    TECH = "tech"
 }
 export declare enum UserRole {
     ADMIN = "admin",

package/dist/schemas/user.schema.js

@@ -19,6 +19,7 @@ var OrganizationTeam;
     OrganizationTeam["ARTISTIC"] = "artistic";
     OrganizationTeam["FINANCIAL"] = "financial";
     OrganizationTeam["COMERCIAL"] = "comercial";
+    OrganizationTeam["TECH"] = "tech";
 })(OrganizationTeam = exports.OrganizationTeam || (exports.OrganizationTeam = {}));
 var UserRole;
 (function (UserRole) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grapadigital/shared-schemas",
-  "version": "1.0.180",
+  "version": "1.0.182",
   "description": "Shared Mongoose Schemas",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -8,6 +8,7 @@ export * from './schemas/payment.schema';
 export * from './schemas/profile.schema';
 export * from './schemas/recruitment.schema';
 export * from './schemas/task.schema';
+export * from './schemas/assignment.schema';
 export * from './schemas/token.schema';
 export * from './schemas/webhook.schema';
 export * from './schemas/sale.schema';

package/src/schemas/assignment.schema.ts

@@ -0,0 +1,149 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { ApiProperty } from '@nestjs/swagger';
+
+import {
+  HydratedDocument,
+  Schema as MongooseSchema,
+  Types,
+  model as MongooseModel,
+} from 'mongoose';
+
+import { Action } from './action.schema';
+
+export type AssignmentDocument = HydratedDocument<Assignment>;
+
+export const ASSIGNMENT_TYPE_VALUES = [
+  'report',
+  'curation',
+  'opt-in',
+  'metrics-monitoring',
+  'data-update',
+  'study',
+] as const;
+export type AssignmentType = (typeof ASSIGNMENT_TYPE_VALUES)[number];
+
+export const ASSIGNMENT_STATUS_VALUES = [
+  'todo',
+  'in-progress',
+  'waiting',
+  'review',
+  'done',
+  'paused',
+  'cancelled',
+  'deleted',
+] as const;
+export type AssignmentStatus = (typeof ASSIGNMENT_STATUS_VALUES)[number];
+
+export const ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES = [
+  'none',
+  'daily',
+  'weekly',
+  'biweekly',
+  'monthly',
+  'yearly',
+  'weekdays',
+  'custom',
+] as const;
+export type AssignmentRecurrenceFrequency =
+  (typeof ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES)[number];
+
+@Schema({ _id: false })
+export class AssignmentRecurrence {
+  @ApiProperty({ enum: ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES, example: 'monthly' })
+  @Prop({
+    type: String,
+    enum: ASSIGNMENT_RECURRENCE_FREQUENCY_VALUES,
+    required: true,
+  })
+  frequency: AssignmentRecurrenceFrequency;
+
+  @ApiProperty({ example: 1, required: false })
+  @Prop({ type: Number, required: false })
+  interval?: number;
+
+  @ApiProperty({ example: [1, 3, 5], required: false })
+  @Prop({ type: [Number], required: false })
+  byWeekday?: number[];
+
+  @ApiProperty({ example: '2026-12-31T00:00:00.000Z', required: false })
+  @Prop({ type: Date, required: false })
+  until?: Date;
+
+  @ApiProperty({ example: 12, required: false })
+  @Prop({ type: Number, required: false })
+  occurrencesCount?: number;
+}
+
+export const AssignmentRecurrenceSchema = SchemaFactory.createForClass(
+  AssignmentRecurrence,
+);
+
+@Schema({ timestamps: true })
+export class Assignment {
+  @ApiProperty({ example: '64bfc3a78d3f1e2a12345670' })
+  @Prop({ type: MongooseSchema.Types.ObjectId, auto: true, required: false })
+  _id?: Types.ObjectId;
+
+  @ApiProperty({ example: '64bfc3a78d3f1e2a12345678' })
+  @Prop({ type: MongooseSchema.Types.ObjectId, ref: 'Action', required: true })
+  action: Types.ObjectId | Action;
+
+  @ApiProperty({ example: '64bfc3a78d3f1e2a12345679' })
+  @Prop({ type: MongooseSchema.Types.ObjectId, required: true })
+  organization: Types.ObjectId;
+
+  @ApiProperty({ enum: ASSIGNMENT_TYPE_VALUES, example: 'report' })
+  @Prop({ type: String, enum: ASSIGNMENT_TYPE_VALUES, required: true })
+  type: AssignmentType;
+
+  @ApiProperty({ example: 'Relatório mensal de performance' })
+  @Prop({ type: String, required: true })
+  title: string;
+
+  @ApiProperty({ example: '64bfc3a78d3f1e2a1234567a', required: false })
+  @Prop({ type: MongooseSchema.Types.ObjectId, required: false })
+  responsible?: Types.ObjectId;
+
+  @ApiProperty({ example: '2026-09-01T00:00:00.000Z', required: false })
+  @Prop({ type: Date, required: false, default: null })
+  dueDate?: Date | null;
+
+  @ApiProperty({ enum: ASSIGNMENT_STATUS_VALUES, example: 'todo' })
+  @Prop({
+    type: String,
+    enum: ASSIGNMENT_STATUS_VALUES,
+    default: 'todo',
+    required: true,
+  })
+  status: AssignmentStatus;
+
+  @ApiProperty({ type: () => AssignmentRecurrence, required: false })
+  @Prop({ type: AssignmentRecurrenceSchema, required: false })
+  recurrence?: AssignmentRecurrence;
+
+  @ApiProperty({ example: '64bfc3a78d3f1e2a1234567b', required: false })
+  @Prop({ type: MongooseSchema.Types.ObjectId, required: false })
+  seriesId?: Types.ObjectId;
+
+  @ApiProperty({ example: 'Aguardando retorno do cliente', required: false })
+  @Prop({ type: String, required: false })
+  notes?: string;
+
+  @ApiProperty({ example: '2026-08-26T15:00:00.000Z' })
+  @Prop({ type: Date, default: Date.now, required: false })
+  createdAt?: Date;
+
+  @ApiProperty({ example: '2026-08-26T15:00:00.000Z' })
+  @Prop({ type: Date, default: Date.now, required: false })
+  updatedAt?: Date;
+}
+
+export const AssignmentSchema = SchemaFactory.createForClass(Assignment);
+
+AssignmentSchema.index({ action: 1 });
+AssignmentSchema.index({ organization: 1, status: 1 });
+AssignmentSchema.index({ organization: 1, dueDate: 1 });
+AssignmentSchema.index({ seriesId: 1 });
+AssignmentSchema.index({ responsible: 1, dueDate: 1 });
+
+export const AssignmentModel = MongooseModel('Assignment', AssignmentSchema);

package/src/schemas/user.schema.ts

@@ -9,6 +9,7 @@ export enum OrganizationTeam {
   ARTISTIC = 'artistic',
   FINANCIAL = 'financial',
   COMERCIAL = 'comercial',
+  TECH = 'tech',
 }
 
 export enum UserRole {