@neutron.co.id/pendidikan-operation 1.29.6 → 1.29.7

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.action.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const query = require('@neon.id/query');
+const checkStudentProgramExistance_schema = require('./checkStudentProgramExistance.schema.cjs');
+const useTelemetry = require('../../providers/useTelemetry.cjs');
+
+const checkStudentProgramExistance = operation.Action.define({
+  key: "checkStudentProgramExistance",
+  name: "Check Student Program Data",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, checkStudentProgramExistance_schema.CheckStudentProgramExistanceSchema);
+    const actions = stream.actions.data;
+    const data = validate(input);
+    return useTelemetry.useTelemetry(stream, "checkStudentProgramExistance", {
+      userId: stream.context.identitas.userId,
+      data
+    }, async () => {
+      const { getActorId } = operation.useStream(stream);
+      try {
+        getActorId({ throw: true });
+        console.log("data", data);
+        const studentPrograms = await actions.getMany.execute({
+          model: "neu:akademik:studentProgram",
+          query: query.Query.define({
+            filter: {
+              $and: [
+                { studentId: data.studentId },
+                { programId: data.programId },
+                { deletedAt: { $exists: false } }
+              ]
+            },
+            fields: {
+              id: 1
+            }
+          })
+        }, stream);
+        const isExist = studentPrograms?.value?.length > 0;
+        return core.Result.ok({
+          state: "checkStudentProgramExistance",
+          message: "Check Student Program Existance",
+          data: {
+            isExist
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return core.Result.fail({
+          state: `checkStudentProgramExistanceFailed`,
+          message: `Failed to check existance Student program.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+exports.checkStudentProgramExistance = checkStudentProgramExistance;

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.action.d.ts

@@ -0,0 +1,13 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { CheckStudentProgramExistanceSchema } from './checkStudentProgramExistance.schema';
+export type CheckStudentProgramExistanceInput = z.parse<typeof CheckStudentProgramExistanceSchema>;
+export interface CheckStudentProgramExistanceOutput {
+}
+export interface CheckStudentProgramExistanceMeta {
+}
+export declare const checkStudentProgramExistance: Action<"checkStudentProgramExistance", {
+    studentId: string;
+    programId: string;
+}, CheckStudentProgramExistanceOutput, CheckStudentProgramExistanceMeta>;
+export type CheckStudentProgramExistanceAction = typeof checkStudentProgramExistance;

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.action.mjs

@@ -0,0 +1,63 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation, useStream } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { Query } from '@neon.id/query';
+import { CheckStudentProgramExistanceSchema } from './checkStudentProgramExistance.schema.mjs';
+import { useTelemetry } from '../../providers/useTelemetry.mjs';
+
+const checkStudentProgramExistance = Action.define({
+  key: "checkStudentProgramExistance",
+  name: "Check Student Program Data",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, CheckStudentProgramExistanceSchema);
+    const actions = stream.actions.data;
+    const data = validate(input);
+    return useTelemetry(stream, "checkStudentProgramExistance", {
+      userId: stream.context.identitas.userId,
+      data
+    }, async () => {
+      const { getActorId } = useStream(stream);
+      try {
+        getActorId({ throw: true });
+        console.log("data", data);
+        const studentPrograms = await actions.getMany.execute({
+          model: "neu:akademik:studentProgram",
+          query: Query.define({
+            filter: {
+              $and: [
+                { studentId: data.studentId },
+                { programId: data.programId },
+                { deletedAt: { $exists: false } }
+              ]
+            },
+            fields: {
+              id: 1
+            }
+          })
+        }, stream);
+        const isExist = studentPrograms?.value?.length > 0;
+        return Result.ok({
+          state: "checkStudentProgramExistance",
+          message: "Check Student Program Existance",
+          data: {
+            isExist
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return Result.fail({
+          state: `checkStudentProgramExistanceFailed`,
+          message: `Failed to check existance Student program.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+export { checkStudentProgramExistance };

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.schema.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const CheckStudentProgramExistanceSchema = z.z.object({
+  studentId: z.z.string().explain({ label: "Student ID" }),
+  programId: z.z.string().explain({ label: "Program Id" })
+});
+
+exports.CheckStudentProgramExistanceSchema = CheckStudentProgramExistanceSchema;

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from '@neon.id/z';
+export declare const CheckStudentProgramExistanceSchema: z.ZodObject<{
+    studentId: z.ZodString;
+    programId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    studentId: string;
+    programId: string;
+}, {
+    studentId: string;
+    programId: string;
+}>;

package/build/actions/checkStudentProgramExistance/checkStudentProgramExistance.schema.mjs

@@ -0,0 +1,8 @@
+import { z } from '@neon.id/z';
+
+const CheckStudentProgramExistanceSchema = z.object({
+  studentId: z.string().explain({ label: "Student ID" }),
+  programId: z.string().explain({ label: "Program Id" })
+});
+
+export { CheckStudentProgramExistanceSchema };

package/build/actions/checkStudentProgramExistance/index.d.ts

@@ -0,0 +1,2 @@
+export * from './checkStudentProgramExistance.action';
+export * from './checkStudentProgramExistance.schema';

package/build/actions/index.d.ts

@@ -11,3 +11,4 @@ export * from './rasionalisasi';
 export * from './tanya';
 export * from './updateMany';
 export * from './checkProgramExistance';
+export * from './checkStudentProgramExistance';

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.action.cjs

@@ -0,0 +1,49 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const getGradingComponentByType_schema = require('./getGradingComponentByType.schema.cjs');
+const useTelemetry = require('../../../providers/useTelemetry.cjs');
+const usePenilaian = require('../../../providers/penilaian/usePenilaian.cjs');
+
+const getGradingComponentByType = operation.Action.define({
+  key: "getGradingComponentByType",
+  name: "Get Grading Component By Type",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, getGradingComponentByType_schema.GetGradingComponentByTypeSchema);
+    const data = validate(input);
+    return useTelemetry.useTelemetry(stream, "getGradingComponentByType", {
+      userId: stream?.context?.identitas?.userId,
+      data
+    }, async () => {
+      try {
+        const { getManyGradingComponent } = usePenilaian.usePenilaian(stream);
+        utils.guard(data.gradingTypeId, "gradingTypeIdRequired");
+        const { items, meta } = await getManyGradingComponent(stream, data.gradingTypeId, data.limit, data.page);
+        return core.Result.ok({
+          state: "getGradingComponentByTypeSuccess",
+          message: "getGradingComponentByType has been sucessfully executed.",
+          data: {
+            gradingComponent: items,
+            meta
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return core.Result.fail({
+          state: `getGradingComponentByTypeFailed`,
+          message: `Failed to getGradingComponentByType.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+exports.getGradingComponentByType = getGradingComponentByType;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.action.d.ts

@@ -0,0 +1,14 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { GetGradingComponentByTypeSchema } from './getGradingComponentByType.schema';
+export type getGradingComponentByTypeInput = z.parse<typeof GetGradingComponentByTypeSchema>;
+export interface getGradingComponentByTypeOutput {
+}
+export interface getGradingComponentByTypeMeta {
+}
+export declare const getGradingComponentByType: Action<"getGradingComponentByType", {
+    gradingTypeId: string;
+    limit: number;
+    page: number;
+}, getGradingComponentByTypeOutput, getGradingComponentByTypeMeta>;
+export type GetGradingComponentByTypeAction = typeof getGradingComponentByType;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.action.mjs

@@ -0,0 +1,47 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { GetGradingComponentByTypeSchema } from './getGradingComponentByType.schema.mjs';
+import { useTelemetry } from '../../../providers/useTelemetry.mjs';
+import { usePenilaian } from '../../../providers/penilaian/usePenilaian.mjs';
+
+const getGradingComponentByType = Action.define({
+  key: "getGradingComponentByType",
+  name: "Get Grading Component By Type",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, GetGradingComponentByTypeSchema);
+    const data = validate(input);
+    return useTelemetry(stream, "getGradingComponentByType", {
+      userId: stream?.context?.identitas?.userId,
+      data
+    }, async () => {
+      try {
+        const { getManyGradingComponent } = usePenilaian(stream);
+        guard(data.gradingTypeId, "gradingTypeIdRequired");
+        const { items, meta } = await getManyGradingComponent(stream, data.gradingTypeId, data.limit, data.page);
+        return Result.ok({
+          state: "getGradingComponentByTypeSuccess",
+          message: "getGradingComponentByType has been sucessfully executed.",
+          data: {
+            gradingComponent: items,
+            meta
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return Result.fail({
+          state: `getGradingComponentByTypeFailed`,
+          message: `Failed to getGradingComponentByType.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+export { getGradingComponentByType };

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.schema.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const GetGradingComponentByTypeSchema = z.z.object({
+  gradingTypeId: z.z.string().explain({ label: "gradingTypeId" }),
+  limit: z.z.number().default(20).explain({ label: "Limit" }),
+  page: z.z.number().default(1).explain({ label: "Page" })
+});
+
+exports.GetGradingComponentByTypeSchema = GetGradingComponentByTypeSchema;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.schema.d.ts

@@ -0,0 +1,14 @@
+import { z } from '@neon.id/z';
+export declare const GetGradingComponentByTypeSchema: z.ZodObject<{
+    gradingTypeId: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    page: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    gradingTypeId: string;
+    limit: number;
+    page: number;
+}, {
+    gradingTypeId: string;
+    limit?: number | undefined;
+    page?: number | undefined;
+}>;

package/build/actions/penilaian/getGradingComponentByType/getGradingComponentByType.schema.mjs

@@ -0,0 +1,9 @@
+import { z } from '@neon.id/z';
+
+const GetGradingComponentByTypeSchema = z.object({
+  gradingTypeId: z.string().explain({ label: "gradingTypeId" }),
+  limit: z.number().default(20).explain({ label: "Limit" }),
+  page: z.number().default(1).explain({ label: "Page" })
+});
+
+export { GetGradingComponentByTypeSchema };

package/build/actions/penilaian/getGradingComponentByType/index.d.ts

@@ -0,0 +1,2 @@
+export * from './getGradingComponentByType.action';
+export * from './getGradingComponentByType.schema';

package/build/actions/penilaian/getGradingStudent/getGradingStudent.action.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const getGradingStudent_schema = require('./getGradingStudent.schema.cjs');
+const useTelemetry = require('../../../providers/useTelemetry.cjs');
+const usePenilaian = require('../../../providers/penilaian/usePenilaian.cjs');
+
+const getGradingStudent = operation.Action.define({
+  key: "getGradingStudent",
+  name: "Get Grading Student",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, getGradingStudent_schema.GetGradingStudentSchema);
+    const data = validate(input);
+    return useTelemetry.useTelemetry(
+      stream,
+      "getGradingStudent",
+      {
+        userId: stream?.context?.identitas?.userId,
+        data
+      },
+      async () => {
+        try {
+          const { getManyGradingByStudent } = usePenilaian.usePenilaian(stream);
+          utils.guard(data.studentId, "studentIdRequired");
+          utils.guard(data.gradingTypeId, "gradingTypeIdRequired");
+          utils.guard(data.branchId, "branchIdRequired");
+          const { items, meta } = await getManyGradingByStudent(
+            stream,
+            data.studentId,
+            data.gradingTypeId,
+            data.branchId,
+            data.limit,
+            data.page
+          );
+          return core.Result.ok({
+            state: "getGradingStudentSuccess",
+            message: "getGradingStudent has been sucessfully executed.",
+            data: {
+              grading: items,
+              meta
+            }
+          });
+        } catch (error) {
+          if (error?.isFailure)
+            throw error;
+          console.error(error);
+          return core.Result.fail({
+            state: `getGradingStudentFailed`,
+            message: `Failed to getGradingStudent.`,
+            error: error?.toString()
+          });
+        }
+      }
+    );
+  }
+});
+
+exports.getGradingStudent = getGradingStudent;

package/build/actions/penilaian/getGradingStudent/getGradingStudent.action.d.ts

@@ -0,0 +1,16 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { GetGradingStudentSchema } from './getGradingStudent.schema';
+export type getGradingStudentInput = z.parse<typeof GetGradingStudentSchema>;
+export interface getGradingStudentOutput {
+}
+export interface getGradingStudentMeta {
+}
+export declare const getGradingStudent: Action<"getGradingStudent", {
+    branchId: string;
+    studentId: string;
+    gradingTypeId: string;
+    limit: number;
+    page: number;
+}, getGradingStudentOutput, getGradingStudentMeta>;
+export type GetGradingStudentAction = typeof getGradingStudent;

package/build/actions/penilaian/getGradingStudent/getGradingStudent.action.mjs

@@ -0,0 +1,61 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { GetGradingStudentSchema } from './getGradingStudent.schema.mjs';
+import { useTelemetry } from '../../../providers/useTelemetry.mjs';
+import { usePenilaian } from '../../../providers/penilaian/usePenilaian.mjs';
+
+const getGradingStudent = Action.define({
+  key: "getGradingStudent",
+  name: "Get Grading Student",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, GetGradingStudentSchema);
+    const data = validate(input);
+    return useTelemetry(
+      stream,
+      "getGradingStudent",
+      {
+        userId: stream?.context?.identitas?.userId,
+        data
+      },
+      async () => {
+        try {
+          const { getManyGradingByStudent } = usePenilaian(stream);
+          guard(data.studentId, "studentIdRequired");
+          guard(data.gradingTypeId, "gradingTypeIdRequired");
+          guard(data.branchId, "branchIdRequired");
+          const { items, meta } = await getManyGradingByStudent(
+            stream,
+            data.studentId,
+            data.gradingTypeId,
+            data.branchId,
+            data.limit,
+            data.page
+          );
+          return Result.ok({
+            state: "getGradingStudentSuccess",
+            message: "getGradingStudent has been sucessfully executed.",
+            data: {
+              grading: items,
+              meta
+            }
+          });
+        } catch (error) {
+          if (error?.isFailure)
+            throw error;
+          console.error(error);
+          return Result.fail({
+            state: `getGradingStudentFailed`,
+            message: `Failed to getGradingStudent.`,
+            error: error?.toString()
+          });
+        }
+      }
+    );
+  }
+});
+
+export { getGradingStudent };

package/build/actions/penilaian/getGradingStudent/getGradingStudent.schema.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const GetGradingStudentSchema = z.z.object({
+  studentId: z.z.string().explain({ label: "studentId" }),
+  gradingTypeId: z.z.string().explain({ label: "gradingTypeId" }),
+  branchId: z.z.string().explain({ label: "branchId" }),
+  limit: z.z.number().default(20).explain({ label: "Limit" }),
+  page: z.z.number().default(1).explain({ label: "Page" })
+});
+
+exports.GetGradingStudentSchema = GetGradingStudentSchema;

package/build/actions/penilaian/getGradingStudent/getGradingStudent.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from '@neon.id/z';
+export declare const GetGradingStudentSchema: z.ZodObject<{
+    studentId: z.ZodString;
+    gradingTypeId: z.ZodString;
+    branchId: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    page: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    branchId: string;
+    studentId: string;
+    gradingTypeId: string;
+    limit: number;
+    page: number;
+}, {
+    branchId: string;
+    studentId: string;
+    gradingTypeId: string;
+    limit?: number | undefined;
+    page?: number | undefined;
+}>;

package/build/actions/penilaian/getGradingStudent/getGradingStudent.schema.mjs

@@ -0,0 +1,11 @@
+import { z } from '@neon.id/z';
+
+const GetGradingStudentSchema = z.object({
+  studentId: z.string().explain({ label: "studentId" }),
+  gradingTypeId: z.string().explain({ label: "gradingTypeId" }),
+  branchId: z.string().explain({ label: "branchId" }),
+  limit: z.number().default(20).explain({ label: "Limit" }),
+  page: z.number().default(1).explain({ label: "Page" })
+});
+
+export { GetGradingStudentSchema };

package/build/actions/penilaian/getGradingStudent/index.d.ts

@@ -0,0 +1,2 @@
+export * from './getGradingStudent.action';
+export * from './getGradingStudent.schema';

package/build/actions/penilaian/getGradingTypeByYear/getGradingTypeByYear.action.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+const core = require('@neon.id/core');
+const operation = require('@neon.id/operation');
+const utils = require('@neon.id/utils');
+const getGradingTypeByYear_schema = require('./getGradingTypeByYear.schema.cjs');
+const useTelemetry = require('../../../providers/useTelemetry.cjs');
+const usePenilaian = require('../../../providers/penilaian/usePenilaian.cjs');
+
+const getGradingTypeByYear = operation.Action.define({
+  key: "getGradingTypeByYear",
+  name: "Get Grading Type By Year",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    utils.guard(stream, "streamRequired");
+    const { validate } = operation.useValidation(stream, getGradingTypeByYear_schema.GetGradingTypeByYearSchema);
+    const data = validate(input);
+    return useTelemetry.useTelemetry(stream, "getGradingTypeByYear", {
+      userId: stream?.context?.identitas?.userId,
+      data
+    }, async () => {
+      try {
+        const { getManyGradingTypes } = usePenilaian.usePenilaian(stream);
+        console.log("data", data);
+        utils.guard(data.year, "yearRequired");
+        const { items, meta } = await getManyGradingTypes(stream, data.year, data.limit, data.page);
+        return core.Result.ok({
+          state: "getGradingTypeByYearSuccess",
+          message: "getGradingTypeByYear has been sucessfully executed.",
+          data: {
+            gradingType: items,
+            meta
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return core.Result.fail({
+          state: `getGradingTypeByYearFailed`,
+          message: `Failed to getGradingTypeByYear.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+exports.getGradingTypeByYear = getGradingTypeByYear;

package/build/actions/penilaian/getGradingTypeByYear/getGradingTypeByYear.action.d.ts

@@ -0,0 +1,14 @@
+import { Action } from '@neon.id/operation';
+import type { z } from '@neon.id/z';
+import { GetGradingTypeByYearSchema } from './getGradingTypeByYear.schema';
+export type getGradingTypeByYearInput = z.parse<typeof GetGradingTypeByYearSchema>;
+export interface getGradingTypeByYearOutput {
+}
+export interface getGradingTypeByYearMeta {
+}
+export declare const getGradingTypeByYear: Action<"getGradingTypeByYear", {
+    year: string;
+    limit: number;
+    page: number;
+}, getGradingTypeByYearOutput, getGradingTypeByYearMeta>;
+export type GetGradingTypeByYearAction = typeof getGradingTypeByYear;

package/build/actions/penilaian/getGradingTypeByYear/getGradingTypeByYear.action.mjs

@@ -0,0 +1,48 @@
+import { Result } from '@neon.id/core';
+import { Action, useValidation } from '@neon.id/operation';
+import { guard } from '@neon.id/utils';
+import { GetGradingTypeByYearSchema } from './getGradingTypeByYear.schema.mjs';
+import { useTelemetry } from '../../../providers/useTelemetry.mjs';
+import { usePenilaian } from '../../../providers/penilaian/usePenilaian.mjs';
+
+const getGradingTypeByYear = Action.define({
+  key: "getGradingTypeByYear",
+  name: "Get Grading Type By Year",
+  type: "command",
+  category: "domain",
+  execute: async (input, stream) => {
+    guard(stream, "streamRequired");
+    const { validate } = useValidation(stream, GetGradingTypeByYearSchema);
+    const data = validate(input);
+    return useTelemetry(stream, "getGradingTypeByYear", {
+      userId: stream?.context?.identitas?.userId,
+      data
+    }, async () => {
+      try {
+        const { getManyGradingTypes } = usePenilaian(stream);
+        console.log("data", data);
+        guard(data.year, "yearRequired");
+        const { items, meta } = await getManyGradingTypes(stream, data.year, data.limit, data.page);
+        return Result.ok({
+          state: "getGradingTypeByYearSuccess",
+          message: "getGradingTypeByYear has been sucessfully executed.",
+          data: {
+            gradingType: items,
+            meta
+          }
+        });
+      } catch (error) {
+        if (error?.isFailure)
+          throw error;
+        console.error(error);
+        return Result.fail({
+          state: `getGradingTypeByYearFailed`,
+          message: `Failed to getGradingTypeByYear.`,
+          error: error?.toString()
+        });
+      }
+    });
+  }
+});
+
+export { getGradingTypeByYear };

package/build/actions/penilaian/getGradingTypeByYear/getGradingTypeByYear.schema.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+const z = require('@neon.id/z');
+
+const GetGradingTypeByYearSchema = z.z.object({
+  year: z.z.string().explain({ label: "Year" }),
+  limit: z.z.number().default(20).explain({ label: "Limit" }),
+  page: z.z.number().default(1).explain({ label: "Page" })
+});
+
+exports.GetGradingTypeByYearSchema = GetGradingTypeByYearSchema;