@zyacreatives/shared 1.9.4 → 1.9.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/constants.d.ts +69 -0
- package/dist/constants.js +62 -1
- package/dist/schemas/index.d.ts +1 -0
- package/dist/schemas/index.js +1 -0
- package/dist/schemas/job-application.d.ts +1 -1
- package/dist/schemas/job.d.ts +338 -0
- package/dist/schemas/job.js +174 -0
- package/dist/types/index.d.ts +1 -0
- package/dist/types/index.js +1 -0
- package/dist/types/job.d.ts +11 -0
- package/dist/types/job.js +2 -0
- package/package.json +1 -1
- package/src/constants.ts +80 -0
- package/src/schemas/index.ts +1 -0
- package/src/schemas/job.ts +231 -0
- package/src/types/index.ts +2 -1
- package/src/types/job.ts +30 -0
package/dist/constants.d.ts
CHANGED
|
@@ -92,6 +92,21 @@ export declare const POST_TYPES: {
|
|
|
92
92
|
readonly POST_WITH_LINKS: "POST_WITH_LINKS";
|
|
93
93
|
readonly POST_WITH_MEDIA: "POST_WITH_MEDIA";
|
|
94
94
|
};
|
|
95
|
+
export declare const JOB_TYPE: {
|
|
96
|
+
GIG: string;
|
|
97
|
+
ROLE: string;
|
|
98
|
+
};
|
|
99
|
+
export declare const WORK_MODE: {
|
|
100
|
+
REMOTE: string;
|
|
101
|
+
HYBRID: string;
|
|
102
|
+
ON_SITE: string;
|
|
103
|
+
};
|
|
104
|
+
export declare const EMPLOYMENT_TYPE: {
|
|
105
|
+
FULL_TIME: string;
|
|
106
|
+
PART_TIME: string;
|
|
107
|
+
FREELANCE: string;
|
|
108
|
+
INTERNSHIP: string;
|
|
109
|
+
};
|
|
95
110
|
export declare const JOB_AVAILABILITY_TYPES: {
|
|
96
111
|
readonly FULL_TIME: "FULL_TIME";
|
|
97
112
|
readonly PART_TIME: "PART_TIME";
|
|
@@ -106,7 +121,61 @@ export declare const WAGE_TYPES: {
|
|
|
106
121
|
readonly MONTHLY: "MONTHLY";
|
|
107
122
|
readonly PROJECT_BASED: "PROJECT_BASED";
|
|
108
123
|
};
|
|
124
|
+
export declare const JOB_SECTIONS: {
|
|
125
|
+
PERSONAL_INFORMATION: string;
|
|
126
|
+
PHONE_NO: string;
|
|
127
|
+
PROFESSIONAL_INFORMATION: string;
|
|
128
|
+
RESUME: string;
|
|
129
|
+
COVER_LETTER: string;
|
|
130
|
+
PORTFOLIO_OR_WORK_SAMPLES: string;
|
|
131
|
+
AVAILABILITY: string;
|
|
132
|
+
WAGES: string;
|
|
133
|
+
};
|
|
134
|
+
export declare const JOB_LOCATIONS: {
|
|
135
|
+
readonly AFRICA: "Africa";
|
|
136
|
+
readonly REMOTE: "Remote";
|
|
137
|
+
readonly EUROPE: "Europe";
|
|
138
|
+
readonly ASIA: "Asia";
|
|
139
|
+
readonly NORTH_AMERICA: "North America";
|
|
140
|
+
readonly SOUTH_AMERICA: "South America";
|
|
141
|
+
readonly MIDDLE_EAST: "Middle East";
|
|
142
|
+
readonly OCEANIA: "Oceania";
|
|
143
|
+
readonly EMEA: "EMEA";
|
|
144
|
+
readonly ASIA_PACIFIC: "Asia Pacific";
|
|
145
|
+
readonly GLOBAL: "Global";
|
|
146
|
+
readonly OTHER: "Other";
|
|
147
|
+
};
|
|
148
|
+
export type JobLocation = (typeof JOB_LOCATIONS)[keyof typeof JOB_LOCATIONS];
|
|
149
|
+
export declare const GIG_TYPE: {
|
|
150
|
+
ONE_TIME: string;
|
|
151
|
+
RECURRING: string;
|
|
152
|
+
};
|
|
153
|
+
export declare const WAGES_CURRENCY: {
|
|
154
|
+
readonly USD: "USD";
|
|
155
|
+
readonly EUR: "EUR";
|
|
156
|
+
readonly GBP: "GBP";
|
|
157
|
+
readonly NGN: "NGN";
|
|
158
|
+
readonly CAD: "CAD";
|
|
159
|
+
readonly AUD: "AUD";
|
|
160
|
+
readonly JPY: "JPY";
|
|
161
|
+
readonly CHF: "CHF";
|
|
162
|
+
readonly INR: "INR";
|
|
163
|
+
readonly ZAR: "ZAR";
|
|
164
|
+
};
|
|
165
|
+
export declare const JOBPOST_STATUS: {
|
|
166
|
+
readonly ACTIVE: "ACTIVE";
|
|
167
|
+
readonly DRAFT: "DRAFT";
|
|
168
|
+
readonly ARCHIVED: "ARCHIVED";
|
|
169
|
+
readonly DELETED: "DELETED";
|
|
170
|
+
};
|
|
171
|
+
export type JobSections = (typeof JOB_SECTIONS)[keyof typeof JOB_SECTIONS];
|
|
172
|
+
export type WagesCurrency = (typeof WAGES_CURRENCY)[keyof typeof WAGES_CURRENCY];
|
|
173
|
+
export type JobPostStatus = (typeof JOBPOST_STATUS)[keyof typeof JOBPOST_STATUS];
|
|
109
174
|
export type Role = (typeof ROLES)[keyof typeof ROLES];
|
|
175
|
+
export type JobType = (typeof JOB_TYPE)[keyof typeof JOB_TYPE];
|
|
176
|
+
export type WorkMode = (typeof WORK_MODE)[keyof typeof WORK_MODE];
|
|
177
|
+
export type GigType = (typeof GIG_TYPE)[keyof typeof GIG_TYPE];
|
|
178
|
+
export type EmploymentType = (typeof EMPLOYMENT_TYPE)[keyof typeof EMPLOYMENT_TYPE];
|
|
110
179
|
export type JobAvailabilityTypes = (typeof JOB_AVAILABILITY_TYPES)[keyof typeof JOB_AVAILABILITY_TYPES];
|
|
111
180
|
export type WageTypes = (typeof WAGE_TYPES)[keyof typeof WAGE_TYPES];
|
|
112
181
|
export type PostType = (typeof POST_TYPES)[keyof typeof POST_TYPES];
|
package/dist/constants.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
"use strict";
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
-
exports.DEFAULT_DISCIPLINES = exports.API_ROUTES = exports.WAGE_TYPES = exports.JOB_AVAILABILITY_TYPES = exports.POST_TYPES = exports.ACTIVITY_PARENT_TYPES = exports.INVESTOR_VERIFICATION_DOCUMENT_TYPES = exports.INVESTOR_VERIFICATION_DOCUMENT_STATUSES = exports.GEOGRAPHIC_FOCUS = exports.INVESTMENT_SIZES = exports.INVESTOR_TYPES = exports.ONBOARDING_PAGES = exports.EXPERIENCE_LEVELS = exports.CLIENT_TYPES = exports.USER_STATUSES = exports.ROLES = void 0;
|
|
3
|
+
exports.DEFAULT_DISCIPLINES = exports.API_ROUTES = exports.JOBPOST_STATUS = exports.WAGES_CURRENCY = exports.GIG_TYPE = exports.JOB_LOCATIONS = exports.JOB_SECTIONS = exports.WAGE_TYPES = exports.JOB_AVAILABILITY_TYPES = exports.EMPLOYMENT_TYPE = exports.WORK_MODE = exports.JOB_TYPE = exports.POST_TYPES = exports.ACTIVITY_PARENT_TYPES = exports.INVESTOR_VERIFICATION_DOCUMENT_TYPES = exports.INVESTOR_VERIFICATION_DOCUMENT_STATUSES = exports.GEOGRAPHIC_FOCUS = exports.INVESTMENT_SIZES = exports.INVESTOR_TYPES = exports.ONBOARDING_PAGES = exports.EXPERIENCE_LEVELS = exports.CLIENT_TYPES = exports.USER_STATUSES = exports.ROLES = void 0;
|
|
4
4
|
exports.ROLES = {
|
|
5
5
|
CREATIVE: "CREATIVE",
|
|
6
6
|
BRAND: "BRAND",
|
|
@@ -95,6 +95,21 @@ exports.POST_TYPES = {
|
|
|
95
95
|
POST_WITH_LINKS: "POST_WITH_LINKS",
|
|
96
96
|
POST_WITH_MEDIA: "POST_WITH_MEDIA",
|
|
97
97
|
};
|
|
98
|
+
exports.JOB_TYPE = {
|
|
99
|
+
GIG: "GIG",
|
|
100
|
+
ROLE: "ROLE",
|
|
101
|
+
};
|
|
102
|
+
exports.WORK_MODE = {
|
|
103
|
+
REMOTE: "REMOTE",
|
|
104
|
+
HYBRID: "HYBRID",
|
|
105
|
+
ON_SITE: "ON_SITE",
|
|
106
|
+
};
|
|
107
|
+
exports.EMPLOYMENT_TYPE = {
|
|
108
|
+
FULL_TIME: "FULL_TIME",
|
|
109
|
+
PART_TIME: "PART_TIME",
|
|
110
|
+
FREELANCE: "FREELANCE",
|
|
111
|
+
INTERNSHIP: "INTERNSHIP",
|
|
112
|
+
};
|
|
98
113
|
exports.JOB_AVAILABILITY_TYPES = {
|
|
99
114
|
FULL_TIME: "FULL_TIME",
|
|
100
115
|
PART_TIME: "PART_TIME",
|
|
@@ -109,6 +124,52 @@ exports.WAGE_TYPES = {
|
|
|
109
124
|
MONTHLY: "MONTHLY",
|
|
110
125
|
PROJECT_BASED: "PROJECT_BASED",
|
|
111
126
|
};
|
|
127
|
+
exports.JOB_SECTIONS = {
|
|
128
|
+
PERSONAL_INFORMATION: "PERSONAL_INFORMATION",
|
|
129
|
+
PHONE_NO: "PHONE_NO",
|
|
130
|
+
PROFESSIONAL_INFORMATION: "PROFESSIONAL_INFORMATION",
|
|
131
|
+
RESUME: "RESUME",
|
|
132
|
+
COVER_LETTER: "COVER_LETTER",
|
|
133
|
+
PORTFOLIO_OR_WORK_SAMPLES: "PORTFOLIO_OR_WORK_SAMPLES",
|
|
134
|
+
AVAILABILITY: "AVAILABILITY",
|
|
135
|
+
WAGES: "WAGES",
|
|
136
|
+
};
|
|
137
|
+
exports.JOB_LOCATIONS = {
|
|
138
|
+
AFRICA: "Africa",
|
|
139
|
+
REMOTE: "Remote",
|
|
140
|
+
EUROPE: "Europe",
|
|
141
|
+
ASIA: "Asia",
|
|
142
|
+
NORTH_AMERICA: "North America",
|
|
143
|
+
SOUTH_AMERICA: "South America",
|
|
144
|
+
MIDDLE_EAST: "Middle East",
|
|
145
|
+
OCEANIA: "Oceania",
|
|
146
|
+
EMEA: "EMEA", // Europe, Middle East, Africa
|
|
147
|
+
ASIA_PACIFIC: "Asia Pacific", // Asia Pacific
|
|
148
|
+
GLOBAL: "Global",
|
|
149
|
+
OTHER: "Other",
|
|
150
|
+
};
|
|
151
|
+
exports.GIG_TYPE = {
|
|
152
|
+
ONE_TIME: "ONE_TIME",
|
|
153
|
+
RECURRING: "RECURRING",
|
|
154
|
+
};
|
|
155
|
+
exports.WAGES_CURRENCY = {
|
|
156
|
+
USD: "USD",
|
|
157
|
+
EUR: "EUR",
|
|
158
|
+
GBP: "GBP",
|
|
159
|
+
NGN: "NGN",
|
|
160
|
+
CAD: "CAD",
|
|
161
|
+
AUD: "AUD",
|
|
162
|
+
JPY: "JPY",
|
|
163
|
+
CHF: "CHF",
|
|
164
|
+
INR: "INR",
|
|
165
|
+
ZAR: "ZAR",
|
|
166
|
+
};
|
|
167
|
+
exports.JOBPOST_STATUS = {
|
|
168
|
+
ACTIVE: "ACTIVE",
|
|
169
|
+
DRAFT: "DRAFT",
|
|
170
|
+
ARCHIVED: "ARCHIVED",
|
|
171
|
+
DELETED: "DELETED",
|
|
172
|
+
};
|
|
112
173
|
exports.API_ROUTES = {
|
|
113
174
|
healthCheck: "/health",
|
|
114
175
|
username: {
|
package/dist/schemas/index.d.ts
CHANGED
package/dist/schemas/index.js
CHANGED
|
@@ -25,4 +25,5 @@ __exportStar(require("./file"), exports);
|
|
|
25
25
|
__exportStar(require("./username"), exports);
|
|
26
26
|
__exportStar(require("./post"), exports);
|
|
27
27
|
__exportStar(require("./entity-stats"), exports);
|
|
28
|
+
__exportStar(require("./job"), exports);
|
|
28
29
|
__exportStar(require("./job-application"), exports);
|
|
@@ -27,8 +27,8 @@ export declare const CreateJobApplicationInputSchema: z.ZodObject<{
|
|
|
27
27
|
availability: z.ZodEnum<{
|
|
28
28
|
FULL_TIME: "FULL_TIME";
|
|
29
29
|
PART_TIME: "PART_TIME";
|
|
30
|
-
CONTRACT: "CONTRACT";
|
|
31
30
|
FREELANCE: "FREELANCE";
|
|
32
31
|
INTERNSHIP: "INTERNSHIP";
|
|
32
|
+
CONTRACT: "CONTRACT";
|
|
33
33
|
}>;
|
|
34
34
|
}, z.core.$strip>;
|
|
@@ -0,0 +1,338 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
export declare const JobEntitySchema: z.ZodObject<{
|
|
3
|
+
id: z.ZodCUID2;
|
|
4
|
+
title: z.ZodString;
|
|
5
|
+
jobType: z.ZodEnum<{
|
|
6
|
+
[x: string]: string;
|
|
7
|
+
}>;
|
|
8
|
+
employmentType: z.ZodNullable<z.ZodEnum<{
|
|
9
|
+
[x: string]: string;
|
|
10
|
+
}>>;
|
|
11
|
+
workMode: z.ZodEnum<{
|
|
12
|
+
[x: string]: string;
|
|
13
|
+
}>;
|
|
14
|
+
gigType: z.ZodNullable<z.ZodEnum<{
|
|
15
|
+
[x: string]: string;
|
|
16
|
+
}>>;
|
|
17
|
+
location: z.ZodArray<z.ZodEnum<{
|
|
18
|
+
Africa: "Africa";
|
|
19
|
+
Asia: "Asia";
|
|
20
|
+
Europe: "Europe";
|
|
21
|
+
"North America": "North America";
|
|
22
|
+
"South America": "South America";
|
|
23
|
+
"Middle East": "Middle East";
|
|
24
|
+
Oceania: "Oceania";
|
|
25
|
+
Global: "Global";
|
|
26
|
+
Other: "Other";
|
|
27
|
+
Remote: "Remote";
|
|
28
|
+
EMEA: "EMEA";
|
|
29
|
+
"Asia Pacific": "Asia Pacific";
|
|
30
|
+
}>>;
|
|
31
|
+
createdAt: z.ZodDate;
|
|
32
|
+
updatedAt: z.ZodDate;
|
|
33
|
+
}, z.core.$strip>;
|
|
34
|
+
export declare const GigJobEntitySchema: z.ZodObject<{
|
|
35
|
+
title: z.ZodString;
|
|
36
|
+
workMode: z.ZodEnum<{
|
|
37
|
+
[x: string]: string;
|
|
38
|
+
}>;
|
|
39
|
+
location: z.ZodArray<z.ZodEnum<{
|
|
40
|
+
Africa: "Africa";
|
|
41
|
+
Asia: "Asia";
|
|
42
|
+
Europe: "Europe";
|
|
43
|
+
"North America": "North America";
|
|
44
|
+
"South America": "South America";
|
|
45
|
+
"Middle East": "Middle East";
|
|
46
|
+
Oceania: "Oceania";
|
|
47
|
+
Global: "Global";
|
|
48
|
+
Other: "Other";
|
|
49
|
+
Remote: "Remote";
|
|
50
|
+
EMEA: "EMEA";
|
|
51
|
+
"Asia Pacific": "Asia Pacific";
|
|
52
|
+
}>>;
|
|
53
|
+
createdAt: z.ZodDate;
|
|
54
|
+
updatedAt: z.ZodDate;
|
|
55
|
+
id: z.ZodCUID2;
|
|
56
|
+
jobType: z.ZodLiteral<string>;
|
|
57
|
+
employmentType: z.ZodNull;
|
|
58
|
+
gigType: z.ZodEnum<{
|
|
59
|
+
[x: string]: string;
|
|
60
|
+
}>;
|
|
61
|
+
overview: z.ZodString;
|
|
62
|
+
deliverables: z.ZodArray<z.ZodString>;
|
|
63
|
+
employeeRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
64
|
+
aboutCompany: z.ZodOptional<z.ZodString>;
|
|
65
|
+
requiredSkills: z.ZodArray<z.ZodString>;
|
|
66
|
+
wagesMin: z.ZodOptional<z.ZodNumber>;
|
|
67
|
+
wagesMax: z.ZodOptional<z.ZodNumber>;
|
|
68
|
+
wagesCurrency: z.ZodOptional<z.ZodEnum<{
|
|
69
|
+
USD: "USD";
|
|
70
|
+
EUR: "EUR";
|
|
71
|
+
GBP: "GBP";
|
|
72
|
+
NGN: "NGN";
|
|
73
|
+
CAD: "CAD";
|
|
74
|
+
AUD: "AUD";
|
|
75
|
+
JPY: "JPY";
|
|
76
|
+
CHF: "CHF";
|
|
77
|
+
INR: "INR";
|
|
78
|
+
ZAR: "ZAR";
|
|
79
|
+
}>>;
|
|
80
|
+
wagesType: z.ZodOptional<z.ZodEnum<{
|
|
81
|
+
HOURLY: "HOURLY";
|
|
82
|
+
DAILY: "DAILY";
|
|
83
|
+
WEEKLY: "WEEKLY";
|
|
84
|
+
MONTHLY: "MONTHLY";
|
|
85
|
+
PROJECT_BASED: "PROJECT_BASED";
|
|
86
|
+
}>>;
|
|
87
|
+
}, z.core.$strip>;
|
|
88
|
+
export declare const RoleJobEntitySchema: z.ZodObject<{
|
|
89
|
+
id: z.ZodCUID2;
|
|
90
|
+
title: z.ZodString;
|
|
91
|
+
workMode: z.ZodEnum<{
|
|
92
|
+
[x: string]: string;
|
|
93
|
+
}>;
|
|
94
|
+
location: z.ZodArray<z.ZodEnum<{
|
|
95
|
+
Africa: "Africa";
|
|
96
|
+
Asia: "Asia";
|
|
97
|
+
Europe: "Europe";
|
|
98
|
+
"North America": "North America";
|
|
99
|
+
"South America": "South America";
|
|
100
|
+
"Middle East": "Middle East";
|
|
101
|
+
Oceania: "Oceania";
|
|
102
|
+
Global: "Global";
|
|
103
|
+
Other: "Other";
|
|
104
|
+
Remote: "Remote";
|
|
105
|
+
EMEA: "EMEA";
|
|
106
|
+
"Asia Pacific": "Asia Pacific";
|
|
107
|
+
}>>;
|
|
108
|
+
createdAt: z.ZodDate;
|
|
109
|
+
updatedAt: z.ZodDate;
|
|
110
|
+
jobType: z.ZodLiteral<string>;
|
|
111
|
+
gigType: z.ZodNull;
|
|
112
|
+
employmentType: z.ZodEnum<{
|
|
113
|
+
[x: string]: string;
|
|
114
|
+
}>;
|
|
115
|
+
experienceLevel: z.ZodEnum<{
|
|
116
|
+
"0-1 year": "0-1 year";
|
|
117
|
+
"1-3 years": "1-3 years";
|
|
118
|
+
"3-5 years": "3-5 years";
|
|
119
|
+
"5+ years": "5+ years";
|
|
120
|
+
}>;
|
|
121
|
+
overview: z.ZodString;
|
|
122
|
+
keyResponsibilities: z.ZodArray<z.ZodString>;
|
|
123
|
+
requiredSkills: z.ZodArray<z.ZodString>;
|
|
124
|
+
employeeRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
125
|
+
companyBenefits: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
126
|
+
wagesMin: z.ZodOptional<z.ZodNumber>;
|
|
127
|
+
wagesMax: z.ZodOptional<z.ZodNumber>;
|
|
128
|
+
wagesCurrency: z.ZodOptional<z.ZodEnum<{
|
|
129
|
+
USD: "USD";
|
|
130
|
+
EUR: "EUR";
|
|
131
|
+
GBP: "GBP";
|
|
132
|
+
NGN: "NGN";
|
|
133
|
+
CAD: "CAD";
|
|
134
|
+
AUD: "AUD";
|
|
135
|
+
JPY: "JPY";
|
|
136
|
+
CHF: "CHF";
|
|
137
|
+
INR: "INR";
|
|
138
|
+
ZAR: "ZAR";
|
|
139
|
+
}>>;
|
|
140
|
+
wagesType: z.ZodOptional<z.ZodEnum<{
|
|
141
|
+
HOURLY: "HOURLY";
|
|
142
|
+
DAILY: "DAILY";
|
|
143
|
+
WEEKLY: "WEEKLY";
|
|
144
|
+
MONTHLY: "MONTHLY";
|
|
145
|
+
PROJECT_BASED: "PROJECT_BASED";
|
|
146
|
+
}>>;
|
|
147
|
+
}, z.core.$strip>;
|
|
148
|
+
export declare const CreateJobInputSchema: z.ZodObject<{
|
|
149
|
+
title: z.ZodString;
|
|
150
|
+
jobType: z.ZodEnum<{
|
|
151
|
+
[x: string]: string;
|
|
152
|
+
}>;
|
|
153
|
+
employmentType: z.ZodEnum<{
|
|
154
|
+
[x: string]: string;
|
|
155
|
+
}>;
|
|
156
|
+
workMode: z.ZodEnum<{
|
|
157
|
+
[x: string]: string;
|
|
158
|
+
}>;
|
|
159
|
+
gigType: z.ZodOptional<z.ZodEnum<{
|
|
160
|
+
[x: string]: string;
|
|
161
|
+
}>>;
|
|
162
|
+
location: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
163
|
+
Africa: "Africa";
|
|
164
|
+
Asia: "Asia";
|
|
165
|
+
Europe: "Europe";
|
|
166
|
+
"North America": "North America";
|
|
167
|
+
"South America": "South America";
|
|
168
|
+
"Middle East": "Middle East";
|
|
169
|
+
Oceania: "Oceania";
|
|
170
|
+
Global: "Global";
|
|
171
|
+
Other: "Other";
|
|
172
|
+
Remote: "Remote";
|
|
173
|
+
EMEA: "EMEA";
|
|
174
|
+
"Asia Pacific": "Asia Pacific";
|
|
175
|
+
}>>>;
|
|
176
|
+
}, z.core.$strip>;
|
|
177
|
+
export declare const CreateRoleJobInputSchema: z.ZodObject<{
|
|
178
|
+
experienceLevel: z.ZodEnum<{
|
|
179
|
+
"0-1 year": "0-1 year";
|
|
180
|
+
"1-3 years": "1-3 years";
|
|
181
|
+
"3-5 years": "3-5 years";
|
|
182
|
+
"5+ years": "5+ years";
|
|
183
|
+
}>;
|
|
184
|
+
overview: z.ZodString;
|
|
185
|
+
keyResponsibilities: z.ZodArray<z.ZodString>;
|
|
186
|
+
requiredSkills: z.ZodArray<z.ZodString>;
|
|
187
|
+
employeeRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
188
|
+
companyBenefits: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
189
|
+
wagesMin: z.ZodOptional<z.ZodNumber>;
|
|
190
|
+
wagesMax: z.ZodOptional<z.ZodNumber>;
|
|
191
|
+
wagesCurrency: z.ZodOptional<z.ZodEnum<{
|
|
192
|
+
USD: "USD";
|
|
193
|
+
EUR: "EUR";
|
|
194
|
+
GBP: "GBP";
|
|
195
|
+
NGN: "NGN";
|
|
196
|
+
CAD: "CAD";
|
|
197
|
+
AUD: "AUD";
|
|
198
|
+
JPY: "JPY";
|
|
199
|
+
CHF: "CHF";
|
|
200
|
+
INR: "INR";
|
|
201
|
+
ZAR: "ZAR";
|
|
202
|
+
}>>;
|
|
203
|
+
wagesType: z.ZodOptional<z.ZodEnum<{
|
|
204
|
+
HOURLY: "HOURLY";
|
|
205
|
+
DAILY: "DAILY";
|
|
206
|
+
WEEKLY: "WEEKLY";
|
|
207
|
+
MONTHLY: "MONTHLY";
|
|
208
|
+
PROJECT_BASED: "PROJECT_BASED";
|
|
209
|
+
}>>;
|
|
210
|
+
}, z.core.$strip>;
|
|
211
|
+
export declare const CreateGigJobInputSchema: z.ZodObject<{
|
|
212
|
+
overview: z.ZodString;
|
|
213
|
+
deliverables: z.ZodArray<z.ZodString>;
|
|
214
|
+
employeeRequirements: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
215
|
+
aboutCompany: z.ZodOptional<z.ZodString>;
|
|
216
|
+
requiredSkills: z.ZodArray<z.ZodString>;
|
|
217
|
+
wagesMin: z.ZodOptional<z.ZodNumber>;
|
|
218
|
+
wagesMax: z.ZodOptional<z.ZodNumber>;
|
|
219
|
+
wagesCurrency: z.ZodOptional<z.ZodEnum<{
|
|
220
|
+
USD: "USD";
|
|
221
|
+
EUR: "EUR";
|
|
222
|
+
GBP: "GBP";
|
|
223
|
+
NGN: "NGN";
|
|
224
|
+
CAD: "CAD";
|
|
225
|
+
AUD: "AUD";
|
|
226
|
+
JPY: "JPY";
|
|
227
|
+
CHF: "CHF";
|
|
228
|
+
INR: "INR";
|
|
229
|
+
ZAR: "ZAR";
|
|
230
|
+
}>>;
|
|
231
|
+
wagesType: z.ZodOptional<z.ZodEnum<{
|
|
232
|
+
HOURLY: "HOURLY";
|
|
233
|
+
DAILY: "DAILY";
|
|
234
|
+
WEEKLY: "WEEKLY";
|
|
235
|
+
MONTHLY: "MONTHLY";
|
|
236
|
+
PROJECT_BASED: "PROJECT_BASED";
|
|
237
|
+
}>>;
|
|
238
|
+
}, z.core.$strip>;
|
|
239
|
+
export declare const UpdateRoleJobInputSchema: z.ZodObject<{
|
|
240
|
+
experienceLevel: z.ZodOptional<z.ZodEnum<{
|
|
241
|
+
"0-1 year": "0-1 year";
|
|
242
|
+
"1-3 years": "1-3 years";
|
|
243
|
+
"3-5 years": "3-5 years";
|
|
244
|
+
"5+ years": "5+ years";
|
|
245
|
+
}>>;
|
|
246
|
+
overview: z.ZodOptional<z.ZodString>;
|
|
247
|
+
keyResponsibilities: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
248
|
+
requiredSkills: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
249
|
+
employeeRequirements: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
|
|
250
|
+
companyBenefits: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
|
|
251
|
+
wagesMin: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
|
|
252
|
+
wagesMax: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
|
|
253
|
+
wagesCurrency: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
|
|
254
|
+
USD: "USD";
|
|
255
|
+
EUR: "EUR";
|
|
256
|
+
GBP: "GBP";
|
|
257
|
+
NGN: "NGN";
|
|
258
|
+
CAD: "CAD";
|
|
259
|
+
AUD: "AUD";
|
|
260
|
+
JPY: "JPY";
|
|
261
|
+
CHF: "CHF";
|
|
262
|
+
INR: "INR";
|
|
263
|
+
ZAR: "ZAR";
|
|
264
|
+
}>>>;
|
|
265
|
+
wagesType: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
|
|
266
|
+
HOURLY: "HOURLY";
|
|
267
|
+
DAILY: "DAILY";
|
|
268
|
+
WEEKLY: "WEEKLY";
|
|
269
|
+
MONTHLY: "MONTHLY";
|
|
270
|
+
PROJECT_BASED: "PROJECT_BASED";
|
|
271
|
+
}>>>;
|
|
272
|
+
id: z.ZodCUID2;
|
|
273
|
+
jobSections: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
274
|
+
[x: string]: string;
|
|
275
|
+
}>>>;
|
|
276
|
+
}, z.core.$strip>;
|
|
277
|
+
export declare const UpdateGigJobInputSchema: z.ZodObject<{
|
|
278
|
+
overview: z.ZodOptional<z.ZodString>;
|
|
279
|
+
deliverables: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
280
|
+
employeeRequirements: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
|
|
281
|
+
aboutCompany: z.ZodOptional<z.ZodOptional<z.ZodString>>;
|
|
282
|
+
requiredSkills: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
283
|
+
wagesMin: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
|
|
284
|
+
wagesMax: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
|
|
285
|
+
wagesCurrency: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
|
|
286
|
+
USD: "USD";
|
|
287
|
+
EUR: "EUR";
|
|
288
|
+
GBP: "GBP";
|
|
289
|
+
NGN: "NGN";
|
|
290
|
+
CAD: "CAD";
|
|
291
|
+
AUD: "AUD";
|
|
292
|
+
JPY: "JPY";
|
|
293
|
+
CHF: "CHF";
|
|
294
|
+
INR: "INR";
|
|
295
|
+
ZAR: "ZAR";
|
|
296
|
+
}>>>;
|
|
297
|
+
wagesType: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
|
|
298
|
+
HOURLY: "HOURLY";
|
|
299
|
+
DAILY: "DAILY";
|
|
300
|
+
WEEKLY: "WEEKLY";
|
|
301
|
+
MONTHLY: "MONTHLY";
|
|
302
|
+
PROJECT_BASED: "PROJECT_BASED";
|
|
303
|
+
}>>>;
|
|
304
|
+
id: z.ZodCUID2;
|
|
305
|
+
jobSections: z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
306
|
+
[x: string]: string;
|
|
307
|
+
}>>>;
|
|
308
|
+
}, z.core.$strip>;
|
|
309
|
+
export declare const UpdateJobInputSchema: z.ZodObject<{
|
|
310
|
+
title: z.ZodOptional<z.ZodString>;
|
|
311
|
+
jobType: z.ZodOptional<z.ZodEnum<{
|
|
312
|
+
[x: string]: string;
|
|
313
|
+
}>>;
|
|
314
|
+
employmentType: z.ZodOptional<z.ZodEnum<{
|
|
315
|
+
[x: string]: string;
|
|
316
|
+
}>>;
|
|
317
|
+
workMode: z.ZodOptional<z.ZodEnum<{
|
|
318
|
+
[x: string]: string;
|
|
319
|
+
}>>;
|
|
320
|
+
gigType: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
|
|
321
|
+
[x: string]: string;
|
|
322
|
+
}>>>;
|
|
323
|
+
location: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodEnum<{
|
|
324
|
+
Africa: "Africa";
|
|
325
|
+
Asia: "Asia";
|
|
326
|
+
Europe: "Europe";
|
|
327
|
+
"North America": "North America";
|
|
328
|
+
"South America": "South America";
|
|
329
|
+
"Middle East": "Middle East";
|
|
330
|
+
Oceania: "Oceania";
|
|
331
|
+
Global: "Global";
|
|
332
|
+
Other: "Other";
|
|
333
|
+
Remote: "Remote";
|
|
334
|
+
EMEA: "EMEA";
|
|
335
|
+
"Asia Pacific": "Asia Pacific";
|
|
336
|
+
}>>>>;
|
|
337
|
+
id: z.ZodCUID2;
|
|
338
|
+
}, z.core.$strip>;
|
|
@@ -0,0 +1,174 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
|
+
exports.UpdateJobInputSchema = exports.UpdateGigJobInputSchema = exports.UpdateRoleJobInputSchema = exports.CreateGigJobInputSchema = exports.CreateRoleJobInputSchema = exports.CreateJobInputSchema = exports.RoleJobEntitySchema = exports.GigJobEntitySchema = exports.JobEntitySchema = void 0;
|
|
4
|
+
const zod_1 = require("zod");
|
|
5
|
+
const constants_1 = require("../constants");
|
|
6
|
+
exports.JobEntitySchema = zod_1.z.object({
|
|
7
|
+
id: zod_1.z.cuid2(),
|
|
8
|
+
title: zod_1.z.string(),
|
|
9
|
+
jobType: zod_1.z.enum(Object.values(constants_1.JOB_TYPE)),
|
|
10
|
+
employmentType: zod_1.z
|
|
11
|
+
.enum(Object.values(constants_1.EMPLOYMENT_TYPE))
|
|
12
|
+
.nullable(), // nullable because GIG jobs don’t have it
|
|
13
|
+
workMode: zod_1.z.enum(Object.values(constants_1.WORK_MODE)),
|
|
14
|
+
gigType: zod_1.z
|
|
15
|
+
.enum(Object.values(constants_1.GIG_TYPE))
|
|
16
|
+
.nullable(), // nullable because ROLE jobs don’t have it
|
|
17
|
+
location: zod_1.z
|
|
18
|
+
.array(zod_1.z.enum(Object.values(constants_1.JOB_LOCATIONS)))
|
|
19
|
+
.nonempty(),
|
|
20
|
+
createdAt: zod_1.z.date(),
|
|
21
|
+
updatedAt: zod_1.z.date(),
|
|
22
|
+
});
|
|
23
|
+
exports.GigJobEntitySchema = exports.JobEntitySchema.extend({
|
|
24
|
+
id: zod_1.z.cuid2(),
|
|
25
|
+
jobType: zod_1.z.literal(constants_1.JOB_TYPE.GIG),
|
|
26
|
+
employmentType: zod_1.z.null(), // enforce null for GIG
|
|
27
|
+
gigType: zod_1.z.enum(Object.values(constants_1.GIG_TYPE)),
|
|
28
|
+
overview: zod_1.z.string(),
|
|
29
|
+
deliverables: zod_1.z.array(zod_1.z.string()),
|
|
30
|
+
employeeRequirements: zod_1.z.array(zod_1.z.string()).optional(),
|
|
31
|
+
aboutCompany: zod_1.z.string().optional(),
|
|
32
|
+
requiredSkills: zod_1.z.array(zod_1.z.string()),
|
|
33
|
+
wagesMin: zod_1.z.number().optional(),
|
|
34
|
+
wagesMax: zod_1.z.number().optional(),
|
|
35
|
+
wagesCurrency: zod_1.z
|
|
36
|
+
.enum(Object.values(constants_1.WAGES_CURRENCY))
|
|
37
|
+
.optional(),
|
|
38
|
+
wagesType: zod_1.z
|
|
39
|
+
.enum(Object.values(constants_1.WAGE_TYPES))
|
|
40
|
+
.optional(),
|
|
41
|
+
});
|
|
42
|
+
exports.RoleJobEntitySchema = exports.JobEntitySchema.extend({
|
|
43
|
+
jobType: zod_1.z.literal(constants_1.JOB_TYPE.ROLE),
|
|
44
|
+
gigType: zod_1.z.null(), // enforce null for ROLE
|
|
45
|
+
employmentType: zod_1.z.enum(Object.values(constants_1.EMPLOYMENT_TYPE)),
|
|
46
|
+
experienceLevel: zod_1.z.enum(Object.values(constants_1.EXPERIENCE_LEVELS)),
|
|
47
|
+
overview: zod_1.z.string(),
|
|
48
|
+
keyResponsibilities: zod_1.z.array(zod_1.z.string()),
|
|
49
|
+
requiredSkills: zod_1.z.array(zod_1.z.string()),
|
|
50
|
+
employeeRequirements: zod_1.z.array(zod_1.z.string()).optional(),
|
|
51
|
+
companyBenefits: zod_1.z.array(zod_1.z.string()).optional(),
|
|
52
|
+
wagesMin: zod_1.z.number().optional(),
|
|
53
|
+
wagesMax: zod_1.z.number().optional(),
|
|
54
|
+
wagesCurrency: zod_1.z
|
|
55
|
+
.enum(Object.values(constants_1.WAGES_CURRENCY))
|
|
56
|
+
.optional(),
|
|
57
|
+
wagesType: zod_1.z
|
|
58
|
+
.enum(Object.values(constants_1.WAGE_TYPES))
|
|
59
|
+
.optional(),
|
|
60
|
+
});
|
|
61
|
+
exports.CreateJobInputSchema = zod_1.z
|
|
62
|
+
.object({
|
|
63
|
+
title: zod_1.z.string(),
|
|
64
|
+
jobType: zod_1.z.enum(Object.values(constants_1.JOB_TYPE)),
|
|
65
|
+
// status: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
|
|
66
|
+
employmentType: zod_1.z.enum(Object.values(constants_1.EMPLOYMENT_TYPE)),
|
|
67
|
+
workMode: zod_1.z.enum(Object.values(constants_1.WORK_MODE)),
|
|
68
|
+
gigType: zod_1.z
|
|
69
|
+
.enum(Object.values(constants_1.GIG_TYPE))
|
|
70
|
+
.optional(),
|
|
71
|
+
location: zod_1.z
|
|
72
|
+
.array(zod_1.z.enum(Object.values(constants_1.JOB_LOCATIONS)))
|
|
73
|
+
.nonempty("At least one job location must be selected")
|
|
74
|
+
.default([constants_1.JOB_LOCATIONS.REMOTE]),
|
|
75
|
+
})
|
|
76
|
+
.superRefine((data, ctx) => {
|
|
77
|
+
if (data.jobType === constants_1.JOB_TYPE.ROLE) {
|
|
78
|
+
if (data.gigType !== undefined) {
|
|
79
|
+
ctx.addIssue({
|
|
80
|
+
path: ["gigType"],
|
|
81
|
+
code: "custom",
|
|
82
|
+
message: "gigType must be null/undefined for PROJECT jobs",
|
|
83
|
+
});
|
|
84
|
+
}
|
|
85
|
+
if (!data.employmentType) {
|
|
86
|
+
ctx.addIssue({
|
|
87
|
+
path: ["employmentType"],
|
|
88
|
+
code: "custom",
|
|
89
|
+
message: "employmentType is required for PROJECT jobs",
|
|
90
|
+
});
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
if (data.jobType === constants_1.JOB_TYPE.GIG) {
|
|
94
|
+
if (!data.gigType) {
|
|
95
|
+
ctx.addIssue({
|
|
96
|
+
path: ["gigType"],
|
|
97
|
+
code: "custom",
|
|
98
|
+
message: "gigType is required for GIG jobs",
|
|
99
|
+
});
|
|
100
|
+
}
|
|
101
|
+
if (data.employmentType !== undefined) {
|
|
102
|
+
ctx.addIssue({
|
|
103
|
+
path: ["employmentType"],
|
|
104
|
+
code: "custom",
|
|
105
|
+
message: "employmentType must be null/undefined for GIG jobs",
|
|
106
|
+
});
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
});
|
|
110
|
+
exports.CreateRoleJobInputSchema = zod_1.z.object({
|
|
111
|
+
experienceLevel: zod_1.z.enum(Object.values(constants_1.EXPERIENCE_LEVELS)),
|
|
112
|
+
overview: zod_1.z.string(),
|
|
113
|
+
keyResponsibilities: zod_1.z.array(zod_1.z.string()),
|
|
114
|
+
requiredSkills: zod_1.z.array(zod_1.z.string()),
|
|
115
|
+
employeeRequirements: zod_1.z.array(zod_1.z.string()).optional(),
|
|
116
|
+
companyBenefits: zod_1.z.array(zod_1.z.string()).optional(),
|
|
117
|
+
wagesMin: zod_1.z.number().optional(),
|
|
118
|
+
wagesMax: zod_1.z.number().optional(),
|
|
119
|
+
wagesCurrency: zod_1.z
|
|
120
|
+
.enum(Object.values(constants_1.WAGES_CURRENCY))
|
|
121
|
+
.optional(),
|
|
122
|
+
wagesType: zod_1.z
|
|
123
|
+
.enum(Object.values(constants_1.WAGE_TYPES))
|
|
124
|
+
.optional(),
|
|
125
|
+
});
|
|
126
|
+
exports.CreateGigJobInputSchema = zod_1.z.object({
|
|
127
|
+
overview: zod_1.z.string(),
|
|
128
|
+
deliverables: zod_1.z.array(zod_1.z.string()),
|
|
129
|
+
employeeRequirements: zod_1.z.array(zod_1.z.string()).optional(),
|
|
130
|
+
aboutCompany: zod_1.z.string().optional(),
|
|
131
|
+
requiredSkills: zod_1.z.array(zod_1.z.string()),
|
|
132
|
+
wagesMin: zod_1.z.number().optional(),
|
|
133
|
+
wagesMax: zod_1.z.number().optional(),
|
|
134
|
+
wagesCurrency: zod_1.z
|
|
135
|
+
.enum(Object.values(constants_1.WAGES_CURRENCY))
|
|
136
|
+
.optional(),
|
|
137
|
+
wagesType: zod_1.z
|
|
138
|
+
.enum(Object.values(constants_1.WAGE_TYPES))
|
|
139
|
+
.optional(),
|
|
140
|
+
});
|
|
141
|
+
const JobSectionEnum = zod_1.z.enum(Object.values(constants_1.JOB_SECTIONS));
|
|
142
|
+
exports.UpdateRoleJobInputSchema = exports.CreateRoleJobInputSchema.partial().extend({
|
|
143
|
+
id: zod_1.z.cuid2(),
|
|
144
|
+
jobSections: zod_1.z
|
|
145
|
+
.array(JobSectionEnum)
|
|
146
|
+
.default([
|
|
147
|
+
constants_1.JOB_SECTIONS.PERSONAL_INFORMATION,
|
|
148
|
+
constants_1.JOB_SECTIONS.PROFESSIONAL_INFORMATION,
|
|
149
|
+
constants_1.JOB_SECTIONS.RESUME,
|
|
150
|
+
])
|
|
151
|
+
.refine((sections) => sections.includes(constants_1.JOB_SECTIONS.PERSONAL_INFORMATION) &&
|
|
152
|
+
sections.includes(constants_1.JOB_SECTIONS.PROFESSIONAL_INFORMATION) &&
|
|
153
|
+
sections.includes(constants_1.JOB_SECTIONS.RESUME), {
|
|
154
|
+
message: "jobSections must always include PERSONAL_INFORMATION, PROFESSIONAL_INFORMATION, and RESUME",
|
|
155
|
+
}),
|
|
156
|
+
});
|
|
157
|
+
exports.UpdateGigJobInputSchema = exports.CreateGigJobInputSchema.partial().extend({
|
|
158
|
+
id: zod_1.z.cuid2(),
|
|
159
|
+
jobSections: zod_1.z
|
|
160
|
+
.array(JobSectionEnum)
|
|
161
|
+
.default([
|
|
162
|
+
constants_1.JOB_SECTIONS.PERSONAL_INFORMATION,
|
|
163
|
+
constants_1.JOB_SECTIONS.PROFESSIONAL_INFORMATION,
|
|
164
|
+
constants_1.JOB_SECTIONS.RESUME,
|
|
165
|
+
])
|
|
166
|
+
.refine((sections) => sections.includes(constants_1.JOB_SECTIONS.PERSONAL_INFORMATION) &&
|
|
167
|
+
sections.includes(constants_1.JOB_SECTIONS.PROFESSIONAL_INFORMATION) &&
|
|
168
|
+
sections.includes(constants_1.JOB_SECTIONS.RESUME), {
|
|
169
|
+
message: "jobSections must always include PERSONAL_INFORMATION, PROFESSIONAL_INFORMATION, and RESUME",
|
|
170
|
+
}),
|
|
171
|
+
});
|
|
172
|
+
exports.UpdateJobInputSchema = exports.CreateJobInputSchema.partial().extend({
|
|
173
|
+
id: zod_1.z.cuid2(),
|
|
174
|
+
});
|
package/dist/types/index.d.ts
CHANGED
package/dist/types/index.js
CHANGED
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
import { JobEntitySchema, GigJobEntitySchema, RoleJobEntitySchema, CreateJobInputSchema, CreateRoleJobInputSchema, CreateGigJobInputSchema, UpdateRoleJobInputSchema, UpdateGigJobInputSchema, UpdateJobInputSchema } from "../schemas/job";
|
|
3
|
+
export type JobEntity = z.infer<typeof JobEntitySchema>;
|
|
4
|
+
export type GigJobEntity = z.infer<typeof GigJobEntitySchema>;
|
|
5
|
+
export type RoleJobEntity = z.infer<typeof RoleJobEntitySchema>;
|
|
6
|
+
export type CreateJobInput = z.infer<typeof CreateJobInputSchema>;
|
|
7
|
+
export type CreateRoleJobInput = z.infer<typeof CreateRoleJobInputSchema>;
|
|
8
|
+
export type CreateGigJobInput = z.infer<typeof CreateGigJobInputSchema>;
|
|
9
|
+
export type UpdateRoleJobInput = z.infer<typeof UpdateRoleJobInputSchema>;
|
|
10
|
+
export type UpdateGigJobInput = z.infer<typeof UpdateGigJobInputSchema>;
|
|
11
|
+
export type UpdateJobInput = z.infer<typeof UpdateJobInputSchema>;
|
package/package.json
CHANGED
package/src/constants.ts
CHANGED
|
@@ -104,6 +104,24 @@ export const POST_TYPES = {
|
|
|
104
104
|
POST_WITH_MEDIA: "POST_WITH_MEDIA",
|
|
105
105
|
} as const;
|
|
106
106
|
|
|
107
|
+
export const JOB_TYPE = {
|
|
108
|
+
GIG: "GIG",
|
|
109
|
+
ROLE: "ROLE",
|
|
110
|
+
};
|
|
111
|
+
|
|
112
|
+
export const WORK_MODE = {
|
|
113
|
+
REMOTE: "REMOTE",
|
|
114
|
+
HYBRID: "HYBRID",
|
|
115
|
+
ON_SITE: "ON_SITE",
|
|
116
|
+
};
|
|
117
|
+
|
|
118
|
+
export const EMPLOYMENT_TYPE = {
|
|
119
|
+
FULL_TIME: "FULL_TIME",
|
|
120
|
+
PART_TIME: "PART_TIME",
|
|
121
|
+
FREELANCE: "FREELANCE",
|
|
122
|
+
INTERNSHIP: "INTERNSHIP",
|
|
123
|
+
};
|
|
124
|
+
|
|
107
125
|
export const JOB_AVAILABILITY_TYPES = {
|
|
108
126
|
FULL_TIME: "FULL_TIME",
|
|
109
127
|
PART_TIME: "PART_TIME",
|
|
@@ -120,7 +138,69 @@ export const WAGE_TYPES = {
|
|
|
120
138
|
PROJECT_BASED: "PROJECT_BASED",
|
|
121
139
|
} as const;
|
|
122
140
|
|
|
141
|
+
export const JOB_SECTIONS = {
|
|
142
|
+
PERSONAL_INFORMATION: "PERSONAL_INFORMATION",
|
|
143
|
+
PHONE_NO: "PHONE_NO",
|
|
144
|
+
PROFESSIONAL_INFORMATION: "PROFESSIONAL_INFORMATION",
|
|
145
|
+
RESUME: "RESUME",
|
|
146
|
+
COVER_LETTER: "COVER_LETTER",
|
|
147
|
+
PORTFOLIO_OR_WORK_SAMPLES: "PORTFOLIO_OR_WORK_SAMPLES",
|
|
148
|
+
AVAILABILITY: "AVAILABILITY",
|
|
149
|
+
WAGES: "WAGES",
|
|
150
|
+
};
|
|
151
|
+
|
|
152
|
+
export const JOB_LOCATIONS = {
|
|
153
|
+
AFRICA: "Africa",
|
|
154
|
+
REMOTE: "Remote",
|
|
155
|
+
EUROPE: "Europe",
|
|
156
|
+
ASIA: "Asia",
|
|
157
|
+
NORTH_AMERICA: "North America",
|
|
158
|
+
SOUTH_AMERICA: "South America",
|
|
159
|
+
MIDDLE_EAST: "Middle East",
|
|
160
|
+
OCEANIA: "Oceania",
|
|
161
|
+
EMEA: "EMEA", // Europe, Middle East, Africa
|
|
162
|
+
ASIA_PACIFIC: "Asia Pacific", // Asia Pacific
|
|
163
|
+
GLOBAL: "Global",
|
|
164
|
+
OTHER: "Other",
|
|
165
|
+
} as const;
|
|
166
|
+
|
|
167
|
+
export type JobLocation = (typeof JOB_LOCATIONS)[keyof typeof JOB_LOCATIONS];
|
|
168
|
+
|
|
169
|
+
export const GIG_TYPE = {
|
|
170
|
+
ONE_TIME: "ONE_TIME",
|
|
171
|
+
RECURRING: "RECURRING",
|
|
172
|
+
};
|
|
173
|
+
export const WAGES_CURRENCY = {
|
|
174
|
+
USD: "USD",
|
|
175
|
+
EUR: "EUR",
|
|
176
|
+
GBP: "GBP",
|
|
177
|
+
NGN: "NGN",
|
|
178
|
+
CAD: "CAD",
|
|
179
|
+
AUD: "AUD",
|
|
180
|
+
JPY: "JPY",
|
|
181
|
+
CHF: "CHF",
|
|
182
|
+
INR: "INR",
|
|
183
|
+
ZAR: "ZAR",
|
|
184
|
+
} as const;
|
|
185
|
+
|
|
186
|
+
export const JOBPOST_STATUS = {
|
|
187
|
+
ACTIVE: "ACTIVE",
|
|
188
|
+
DRAFT: "DRAFT",
|
|
189
|
+
ARCHIVED: "ARCHIVED",
|
|
190
|
+
DELETED: "DELETED",
|
|
191
|
+
} as const;
|
|
192
|
+
|
|
193
|
+
export type JobSections = (typeof JOB_SECTIONS)[keyof typeof JOB_SECTIONS];
|
|
194
|
+
export type WagesCurrency =
|
|
195
|
+
(typeof WAGES_CURRENCY)[keyof typeof WAGES_CURRENCY];
|
|
196
|
+
export type JobPostStatus =
|
|
197
|
+
(typeof JOBPOST_STATUS)[keyof typeof JOBPOST_STATUS];
|
|
123
198
|
export type Role = (typeof ROLES)[keyof typeof ROLES];
|
|
199
|
+
export type JobType = (typeof JOB_TYPE)[keyof typeof JOB_TYPE];
|
|
200
|
+
export type WorkMode = (typeof WORK_MODE)[keyof typeof WORK_MODE];
|
|
201
|
+
export type GigType = (typeof GIG_TYPE)[keyof typeof GIG_TYPE];
|
|
202
|
+
export type EmploymentType =
|
|
203
|
+
(typeof EMPLOYMENT_TYPE)[keyof typeof EMPLOYMENT_TYPE];
|
|
124
204
|
export type JobAvailabilityTypes =
|
|
125
205
|
(typeof JOB_AVAILABILITY_TYPES)[keyof typeof JOB_AVAILABILITY_TYPES];
|
|
126
206
|
export type WageTypes = (typeof WAGE_TYPES)[keyof typeof WAGE_TYPES];
|
package/src/schemas/index.ts
CHANGED
|
@@ -0,0 +1,231 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
import {
|
|
3
|
+
EMPLOYMENT_TYPE,
|
|
4
|
+
EmploymentType,
|
|
5
|
+
EXPERIENCE_LEVELS,
|
|
6
|
+
ExperienceLevel,
|
|
7
|
+
GIG_TYPE,
|
|
8
|
+
GigType,
|
|
9
|
+
JOB_AVAILABILITY_TYPES,
|
|
10
|
+
JOB_LOCATIONS,
|
|
11
|
+
JOB_SECTIONS,
|
|
12
|
+
JOB_TYPE,
|
|
13
|
+
JobAvailabilityTypes,
|
|
14
|
+
JobLocation,
|
|
15
|
+
JobType,
|
|
16
|
+
WAGE_TYPES,
|
|
17
|
+
WAGES_CURRENCY,
|
|
18
|
+
WagesCurrency,
|
|
19
|
+
WageTypes,
|
|
20
|
+
WORK_MODE,
|
|
21
|
+
WorkMode,
|
|
22
|
+
} from "../constants";
|
|
23
|
+
|
|
24
|
+
export const JobEntitySchema = z.object({
|
|
25
|
+
id: z.cuid2(),
|
|
26
|
+
title: z.string(),
|
|
27
|
+
jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
|
|
28
|
+
employmentType: z
|
|
29
|
+
.enum(
|
|
30
|
+
Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
|
|
31
|
+
)
|
|
32
|
+
.nullable(), // nullable because GIG jobs don’t have it
|
|
33
|
+
workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
|
|
34
|
+
gigType: z
|
|
35
|
+
.enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
|
|
36
|
+
.nullable(), // nullable because ROLE jobs don’t have it
|
|
37
|
+
location: z
|
|
38
|
+
.array(
|
|
39
|
+
z.enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
|
|
40
|
+
)
|
|
41
|
+
.nonempty(),
|
|
42
|
+
createdAt: z.date(),
|
|
43
|
+
updatedAt: z.date(),
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
export const GigJobEntitySchema = JobEntitySchema.extend({
|
|
47
|
+
id: z.cuid2(),
|
|
48
|
+
jobType: z.literal(JOB_TYPE.GIG),
|
|
49
|
+
employmentType: z.null(), // enforce null for GIG
|
|
50
|
+
gigType: z.enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]]),
|
|
51
|
+
overview: z.string(),
|
|
52
|
+
deliverables: z.array(z.string()),
|
|
53
|
+
employeeRequirements: z.array(z.string()).optional(),
|
|
54
|
+
aboutCompany: z.string().optional(),
|
|
55
|
+
requiredSkills: z.array(z.string()),
|
|
56
|
+
wagesMin: z.number().optional(),
|
|
57
|
+
wagesMax: z.number().optional(),
|
|
58
|
+
wagesCurrency: z
|
|
59
|
+
.enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
|
|
60
|
+
.optional(),
|
|
61
|
+
wagesType: z
|
|
62
|
+
.enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
|
|
63
|
+
.optional(),
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
export const RoleJobEntitySchema = JobEntitySchema.extend({
|
|
67
|
+
jobType: z.literal(JOB_TYPE.ROLE),
|
|
68
|
+
gigType: z.null(), // enforce null for ROLE
|
|
69
|
+
employmentType: z.enum(
|
|
70
|
+
Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
|
|
71
|
+
),
|
|
72
|
+
experienceLevel: z.enum(
|
|
73
|
+
Object.values(EXPERIENCE_LEVELS) as [ExperienceLevel, ...ExperienceLevel[]]
|
|
74
|
+
),
|
|
75
|
+
overview: z.string(),
|
|
76
|
+
keyResponsibilities: z.array(z.string()),
|
|
77
|
+
requiredSkills: z.array(z.string()),
|
|
78
|
+
employeeRequirements: z.array(z.string()).optional(),
|
|
79
|
+
companyBenefits: z.array(z.string()).optional(),
|
|
80
|
+
wagesMin: z.number().optional(),
|
|
81
|
+
wagesMax: z.number().optional(),
|
|
82
|
+
wagesCurrency: z
|
|
83
|
+
.enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
|
|
84
|
+
.optional(),
|
|
85
|
+
wagesType: z
|
|
86
|
+
.enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
|
|
87
|
+
.optional(),
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
export const CreateJobInputSchema = z
|
|
91
|
+
.object({
|
|
92
|
+
title: z.string(),
|
|
93
|
+
jobType: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
|
|
94
|
+
// status: z.enum(Object.values(JOB_TYPE) as [JobType, ...JobType[]]),
|
|
95
|
+
employmentType: z.enum(
|
|
96
|
+
Object.values(EMPLOYMENT_TYPE) as [EmploymentType, ...EmploymentType[]]
|
|
97
|
+
),
|
|
98
|
+
workMode: z.enum(Object.values(WORK_MODE) as [WorkMode, ...WorkMode[]]),
|
|
99
|
+
gigType: z
|
|
100
|
+
.enum(Object.values(GIG_TYPE) as [GigType, ...GigType[]])
|
|
101
|
+
.optional(),
|
|
102
|
+
location: z
|
|
103
|
+
.array(
|
|
104
|
+
z.enum(Object.values(JOB_LOCATIONS) as [JobLocation, ...JobLocation[]])
|
|
105
|
+
)
|
|
106
|
+
.nonempty("At least one job location must be selected")
|
|
107
|
+
.default([JOB_LOCATIONS.REMOTE]),
|
|
108
|
+
})
|
|
109
|
+
.superRefine((data, ctx) => {
|
|
110
|
+
if (data.jobType === JOB_TYPE.ROLE) {
|
|
111
|
+
if (data.gigType !== undefined) {
|
|
112
|
+
ctx.addIssue({
|
|
113
|
+
path: ["gigType"],
|
|
114
|
+
code: "custom",
|
|
115
|
+
message: "gigType must be null/undefined for PROJECT jobs",
|
|
116
|
+
});
|
|
117
|
+
}
|
|
118
|
+
if (!data.employmentType) {
|
|
119
|
+
ctx.addIssue({
|
|
120
|
+
path: ["employmentType"],
|
|
121
|
+
code: "custom",
|
|
122
|
+
message: "employmentType is required for PROJECT jobs",
|
|
123
|
+
});
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
|
|
127
|
+
if (data.jobType === JOB_TYPE.GIG) {
|
|
128
|
+
if (!data.gigType) {
|
|
129
|
+
ctx.addIssue({
|
|
130
|
+
path: ["gigType"],
|
|
131
|
+
code: "custom",
|
|
132
|
+
message: "gigType is required for GIG jobs",
|
|
133
|
+
});
|
|
134
|
+
}
|
|
135
|
+
if (data.employmentType !== undefined) {
|
|
136
|
+
ctx.addIssue({
|
|
137
|
+
path: ["employmentType"],
|
|
138
|
+
code: "custom",
|
|
139
|
+
message: "employmentType must be null/undefined for GIG jobs",
|
|
140
|
+
});
|
|
141
|
+
}
|
|
142
|
+
}
|
|
143
|
+
});
|
|
144
|
+
|
|
145
|
+
export const CreateRoleJobInputSchema = z.object({
|
|
146
|
+
experienceLevel: z.enum(
|
|
147
|
+
Object.values(EXPERIENCE_LEVELS) as [ExperienceLevel, ...ExperienceLevel[]]
|
|
148
|
+
),
|
|
149
|
+
overview: z.string(),
|
|
150
|
+
keyResponsibilities: z.array(z.string()),
|
|
151
|
+
requiredSkills: z.array(z.string()),
|
|
152
|
+
employeeRequirements: z.array(z.string()).optional(),
|
|
153
|
+
companyBenefits: z.array(z.string()).optional(),
|
|
154
|
+
wagesMin: z.number().optional(),
|
|
155
|
+
wagesMax: z.number().optional(),
|
|
156
|
+
wagesCurrency: z
|
|
157
|
+
.enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
|
|
158
|
+
.optional(),
|
|
159
|
+
wagesType: z
|
|
160
|
+
.enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
|
|
161
|
+
.optional(),
|
|
162
|
+
});
|
|
163
|
+
|
|
164
|
+
export const CreateGigJobInputSchema = z.object({
|
|
165
|
+
overview: z.string(),
|
|
166
|
+
deliverables: z.array(z.string()),
|
|
167
|
+
employeeRequirements: z.array(z.string()).optional(),
|
|
168
|
+
aboutCompany: z.string().optional(),
|
|
169
|
+
requiredSkills: z.array(z.string()),
|
|
170
|
+
wagesMin: z.number().optional(),
|
|
171
|
+
wagesMax: z.number().optional(),
|
|
172
|
+
wagesCurrency: z
|
|
173
|
+
.enum(Object.values(WAGES_CURRENCY) as [WagesCurrency, ...WagesCurrency[]])
|
|
174
|
+
.optional(),
|
|
175
|
+
wagesType: z
|
|
176
|
+
.enum(Object.values(WAGE_TYPES) as [WageTypes, ...WageTypes[]])
|
|
177
|
+
.optional(),
|
|
178
|
+
});
|
|
179
|
+
|
|
180
|
+
const JobSectionEnum = z.enum(
|
|
181
|
+
Object.values(JOB_SECTIONS) as [string, ...string[]]
|
|
182
|
+
);
|
|
183
|
+
|
|
184
|
+
export const UpdateRoleJobInputSchema =
|
|
185
|
+
CreateRoleJobInputSchema.partial().extend({
|
|
186
|
+
id: z.cuid2(),
|
|
187
|
+
jobSections: z
|
|
188
|
+
.array(JobSectionEnum)
|
|
189
|
+
.default([
|
|
190
|
+
JOB_SECTIONS.PERSONAL_INFORMATION,
|
|
191
|
+
JOB_SECTIONS.PROFESSIONAL_INFORMATION,
|
|
192
|
+
JOB_SECTIONS.RESUME,
|
|
193
|
+
])
|
|
194
|
+
.refine(
|
|
195
|
+
(sections) =>
|
|
196
|
+
sections.includes(JOB_SECTIONS.PERSONAL_INFORMATION) &&
|
|
197
|
+
sections.includes(JOB_SECTIONS.PROFESSIONAL_INFORMATION) &&
|
|
198
|
+
sections.includes(JOB_SECTIONS.RESUME),
|
|
199
|
+
{
|
|
200
|
+
message:
|
|
201
|
+
"jobSections must always include PERSONAL_INFORMATION, PROFESSIONAL_INFORMATION, and RESUME",
|
|
202
|
+
}
|
|
203
|
+
),
|
|
204
|
+
});
|
|
205
|
+
|
|
206
|
+
export const UpdateGigJobInputSchema = CreateGigJobInputSchema.partial().extend(
|
|
207
|
+
{
|
|
208
|
+
id: z.cuid2(),
|
|
209
|
+
jobSections: z
|
|
210
|
+
.array(JobSectionEnum)
|
|
211
|
+
.default([
|
|
212
|
+
JOB_SECTIONS.PERSONAL_INFORMATION,
|
|
213
|
+
JOB_SECTIONS.PROFESSIONAL_INFORMATION,
|
|
214
|
+
JOB_SECTIONS.RESUME,
|
|
215
|
+
])
|
|
216
|
+
.refine(
|
|
217
|
+
(sections) =>
|
|
218
|
+
sections.includes(JOB_SECTIONS.PERSONAL_INFORMATION) &&
|
|
219
|
+
sections.includes(JOB_SECTIONS.PROFESSIONAL_INFORMATION) &&
|
|
220
|
+
sections.includes(JOB_SECTIONS.RESUME),
|
|
221
|
+
{
|
|
222
|
+
message:
|
|
223
|
+
"jobSections must always include PERSONAL_INFORMATION, PROFESSIONAL_INFORMATION, and RESUME",
|
|
224
|
+
}
|
|
225
|
+
),
|
|
226
|
+
}
|
|
227
|
+
);
|
|
228
|
+
|
|
229
|
+
export const UpdateJobInputSchema = CreateJobInputSchema.partial().extend({
|
|
230
|
+
id: z.cuid2(),
|
|
231
|
+
});
|
package/src/types/index.ts
CHANGED
package/src/types/job.ts
ADDED
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
import {
|
|
3
|
+
JobEntitySchema,
|
|
4
|
+
GigJobEntitySchema,
|
|
5
|
+
RoleJobEntitySchema,
|
|
6
|
+
CreateJobInputSchema,
|
|
7
|
+
CreateRoleJobInputSchema,
|
|
8
|
+
CreateGigJobInputSchema,
|
|
9
|
+
UpdateRoleJobInputSchema,
|
|
10
|
+
UpdateGigJobInputSchema,
|
|
11
|
+
UpdateJobInputSchema,
|
|
12
|
+
} from "../schemas/job";
|
|
13
|
+
|
|
14
|
+
export type JobEntity = z.infer<typeof JobEntitySchema>;
|
|
15
|
+
|
|
16
|
+
export type GigJobEntity = z.infer<typeof GigJobEntitySchema>;
|
|
17
|
+
|
|
18
|
+
export type RoleJobEntity = z.infer<typeof RoleJobEntitySchema>;
|
|
19
|
+
|
|
20
|
+
export type CreateJobInput = z.infer<typeof CreateJobInputSchema>;
|
|
21
|
+
|
|
22
|
+
export type CreateRoleJobInput = z.infer<typeof CreateRoleJobInputSchema>;
|
|
23
|
+
|
|
24
|
+
export type CreateGigJobInput = z.infer<typeof CreateGigJobInputSchema>;
|
|
25
|
+
|
|
26
|
+
export type UpdateRoleJobInput = z.infer<typeof UpdateRoleJobInputSchema>;
|
|
27
|
+
|
|
28
|
+
export type UpdateGigJobInput = z.infer<typeof UpdateGigJobInputSchema>;
|
|
29
|
+
|
|
30
|
+
export type UpdateJobInput = z.infer<typeof UpdateJobInputSchema>;
|