wcz-layout 6.7.2 → 8.3.2

package/skills/services/docs/approval.md

@@ -0,0 +1,204 @@
+# approval
+
+## Client
+
+- Query:
+  `approvalsQueryOptions`
+  `approvalQueryOptions`
+- Mutation:
+  `createApprovalMutationOptions`
+  `approveApprovalMutationOptions`
+  `resubmitApprovalMutationOptions`
+  `withdrawApprovalMutationOptions`
+  `cancelApprovalMutationOptions`
+
+## Server
+
+- Fetch:
+  `getApprovals`
+  `getApproval`
+- Mutate:
+  `createApproval`
+  `approveApproval`
+  `resubmitApproval`
+  `withdrawApproval`
+  `cancelApproval`
+
+## Schemas/Models
+
+```ts
+const ApprovalRequestType = z.enum(["Single", "Batch"]);
+
+const ApprovalStatus = z.enum([
+  "WaitingForApproval",
+  "Approved",
+  "PartiallyApproved",
+  "Rejected",
+  "Withdrawn",
+  "Cancelled",
+]);
+
+const ApprovalStepResult = z.enum([
+  "NotAvailable",
+  "FutureApproval",
+  "WaitingForApproval",
+  "Approved",
+  "Rejected",
+  "Skipped",
+  "Withdrawn",
+  "Cancelled",
+]);
+
+const StepApprovalOrder = z.enum(["Serial", "Parallel", "OneOfThem"]);
+
+const ApprovalEmployeeSchema = z.object({
+  employeeId: z.string().trim().min(1).max(20),
+  name: z.string().trim().min(1).max(50),
+  email: z.email().min(1).max(100),
+});
+
+const ApprovalCoRequestorSchema = z.object({
+  employeeId: z.string().trim().min(1).max(20),
+  name: z.string().trim().min(1).max(50),
+  email: z.email().min(1).max(100),
+});
+
+const ApprovalFlowStepSchema = z.object({
+  id: z.uuid(),
+  order: z.number(),
+  approverRole: z.string().trim().min(1).max(100).default("Approver").optional(),
+  approver: ApprovalEmployeeSchema,
+  actualApprover: ApprovalEmployeeSchema.optional(),
+  result: ApprovalStepResult.default("NotAvailable").optional(),
+  resultDate: z.date().optional(),
+  resultComment: z.string().trim().max(2000).optional(),
+});
+
+const ApprovalFlowSchema = z.object({
+  id: z.uuid(),
+  approvalStage: z.number(),
+  batchSequence: z.number().optional(),
+  approvalSequence: z.number(),
+  stepApprovalOrder: StepApprovalOrder,
+  steps: z.array(ApprovalFlowStepSchema),
+  isActive: z.boolean().default(false).optional(),
+});
+
+const ApprovalCoRequestorGroupSchema = z.object({
+  role: z.string().trim().min(1),
+  email: z.email().optional(),
+});
+
+const ApprovalCoRequestorEmployeeSchema = z.object({
+  employeeId: z.string().trim().min(1),
+  name: z.string().trim().min(1),
+  email: z.email().optional(),
+});
+
+const ApprovalCoRequestorPrincipalSchema = z.union([
+  ApprovalCoRequestorGroupSchema,
+  ApprovalCoRequestorEmployeeSchema,
+]);
+
+const ApprovalSchema = z.object({
+  id: z.uuid(),
+  number: z.string().trim().max(30).optional(),
+  applicationName: z.string().trim().min(1).max(50),
+  type: ApprovalRequestType.default("Single").optional(),
+  status: ApprovalStatus,
+  created: z.date(),
+  createdBy: z.custom<ApprovalEmployee>(),
+  updated: z.date().optional(),
+  updatedBy: z.custom<ApprovalEmployee>().optional(),
+  approvalFlows: z.array(ApprovalFlow).min(1),
+  currentApprovers: z.array(ApprovalEmployee),
+  coRequestors: z
+    .array(z.object({ id: z.uuid(), principal: ApprovalCoRequestorPrincipalSchema }))
+    .optional(),
+});
+
+const GetApprovalsSchema = z.object({
+  appName: z.string().min(1).max(255),
+  status: ApprovalStatus.optional(),
+  approverEmployeeId: z.string().min(1).max(20).optional(),
+  stepResult: ApprovalStepResult.optional(),
+});
+
+const GetApprovalSchema = z.object({
+  id: z.uuid(),
+});
+
+const CreateApprovalSchema = ApprovalSchema.pick({
+  id: true,
+  number: true,
+  applicationName: true,
+  type: true,
+  status: true,
+  approvalFlows: true,
+}).extend({
+  emailBody: z.string().trim().min(1),
+  approvalFlows: z
+    .array(
+      ApprovalFlowSchema.pick({
+        approvalStage: true,
+        batchSequence: true,
+        stepApprovalOrder: true,
+        steps: true,
+      }).extend({
+        steps: z.array(ApprovalFlowStepSchema.pick({ approverRole: true, approver: true })),
+      }),
+    )
+    .min(1),
+  coRequestors: z.array(ApprovalCoRequestorPrincipalSchema).optional(),
+});
+
+const ApproveApprovalSchema = z.object({
+  id: z.uuid(),
+  result: ApprovalStepResult,
+  resultComment: z.string().trim().max(2000).optional(),
+  emailBody: z.string().trim().min(1),
+});
+
+const ResubmitApprovalSchema = ApprovalSchema.pick({
+  id: true,
+  approvalFlows: true,
+}).extend({
+  approvalFlows: z
+    .array(
+      ApprovalFlowSchema.pick({
+        approvalStage: true,
+        batchSequence: true,
+        stepApprovalOrder: true,
+        steps: true,
+      }).extend({
+        steps: z.array(ApprovalFlowStepSchema.pick({ approverRole: true, approver: true })),
+      }),
+    )
+    .min(1),
+});
+
+const CancelApprovalSchema = z.object({
+  id: z.uuid(),
+  comment: z.string().trim().min(1).max(2000),
+  emailBody: z.string().trim().min(1),
+});
+
+const WithdrawApprovalSchema = z.object({
+  id: z.uuid(),
+  comment: z.string().trim().min(1).max(2000),
+  emailBody: z.string().trim().min(1),
+});
+```
+
+## Examples
+
+```ts
+import { approvalQueryOptions } from "wcz-layout/data/client";
+import { approveApproval } from "wcz-layout/data/server";
+
+// client
+const { data: approval } = useQuery(approvalQueryOptions({ id }));
+
+// server
+await approveApproval({ data: { id, result: "Approved", emailBody } });
+```

package/skills/services/docs/email.md

@@ -0,0 +1,32 @@
+# email
+
+## Server
+
+- `sendEmail`
+
+## Schemas/Models
+
+```ts
+const EmailSchema = z.object({
+  subject: z.string().trim().min(1).max(60),
+  body: z.string().trim().min(1),
+  to: z.array(z.email()).min(1),
+  bcc: z.array(z.email()).optional(),
+  cc: z.array(z.email()).optional(),
+  attachments: z.array(EmailAttachmentSchema).optional(),
+});
+
+const EmailAttachmentSchema = z.object({
+  appName: z.string().trim().min(1).max(100),
+  subId: z.uuid(),
+});
+```
+
+## Examples
+
+```ts
+import { sendEmail } from "wcz-layout/data/server";
+
+// server
+await sendEmail({ data: { subject: "Hello", body: "<p>Hi</p>", to: ["user@example.com"] } });
+```

package/skills/services/docs/file.md

@@ -0,0 +1,85 @@
+# file
+
+## Client
+
+- Query:
+  `fileMetasQueryOptions`
+  `fileThumbnailQueryOptions`
+  `fileQueryOptions`
+- Mutation:
+  `downloadFileMutationOptions`
+  `openFileMutationOptions`
+  `updateFileMetaMutationOptions`
+  `deleteFileMutationOptions`
+  `batchDeleteFilesMutationOptions`
+- Hooks:
+  `useUploadFile`
+
+## Server
+
+- Fetch:
+  `getFileMetas`
+  `getFileThumbnail`
+  `getFile`
+  `downloadFile`.
+- Mutate:
+  `updateFileMeta`
+  `deleteFile`
+  `batchDeleteFiles`
+  `uploadFile`
+
+## Schemas/Models
+
+```ts
+const FileMetaSchema = z.object({
+  id: z.uuid(),
+  subId: z.uuid(),
+  appName: z.string().trim().min(1).max(255),
+  fileName: z.string().trim().min(1).max(255),
+  fileExtension: z.string().trim().min(1).max(255),
+  fileSize: z.number().min(0),
+  mediaSubType: z.string().trim().min(1).max(255),
+  mediaType: z.string().trim().min(1).max(255),
+  mimeType: z.string().trim().min(1).max(255),
+  createdBy: z.string().trim().min(1).max(255),
+  createdDate: z.date(),
+});
+
+const FileActionsSchema = z.object({
+  download: z.boolean().optional(),
+  delete: z.boolean().optional(),
+});
+
+const GetFileMetasSchema = z.object({
+  appName: z.string().min(1).max(255),
+  subId: z.uuid(),
+});
+
+const FileSchema = z.object({
+  appName: z.string().min(1).max(255),
+  id: z.uuid(),
+});
+
+const UpdateFileMetaSchema = FileMetaSchema.extend({
+  fileName: z.string().min(1).max(255),
+});
+
+const UploadFileMetaSchema = z.object({
+  appName: z.string().min(1).max(255),
+  subId: z.uuid(),
+  file: z.instanceof(File),
+});
+```
+
+## Examples
+
+```ts
+import { fileMetasQueryOptions } from "wcz-layout/data/client";
+import { uploadFile } from "wcz-layout/data/server";
+
+// client
+const { data: files = [] } = useQuery(fileMetasQueryOptions({ appName, subId }));
+
+// server
+await uploadFile({ data: { appName, subId, file } });
+```

package/skills/services/docs/peoplesoft.md

@@ -0,0 +1,110 @@
+# peoplesoft
+
+## Client
+
+- Employee:
+  `employeesSearchQueryOptions`
+  `employeesQueryOptions`
+  `activeEmployeesQueryOptions`
+  `employeeByIdQueryOptions`
+  `previousEmployeeIdsQueryOptions`
+  `employeeSupervisorQueryOptions`
+  `employeeSubordinatesQueryOptions`
+  `employeeManagerQueryOptions`
+  `employeeGeneralManagerQueryOptions`
+  `companyGeneralManagerQueryOptions`
+- Department:
+  `departmentsQueryOptions`
+  `departmentByIdQueryOptions`
+  `departmentManagerQueryOptions`
+  `departmentEmployeesQueryOptions`
+
+## Server
+
+- Employee:
+  `searchEmployees`
+  `getEmployees`
+  `getActiveEmployees`
+  `getEmployeeByEmployeeId`
+  `getPreviousEmployeeIds`
+  `getEmployeeSupervisor`
+  `getEmployeeSubordinates`
+  `getEmployeeManager`
+  `getEmployeeGeneralManager`
+  `getCompanyGeneralManager`
+- Department:
+  `getDepartments`
+  `getDepartmentById`
+  `getDepartmentManager`
+  `getDepartmentEmployees`
+
+## Schemas/Models
+
+```ts
+const EmployeeSchema = z.object({
+  badgeId: z.string().trim(),
+  category: z.string().trim(),
+  categoryGroup: EmployeeCategoryGroup,
+  companyCode: z.string().trim(),
+  contactPhone: z.string().trim(),
+  departmentId: z.string().trim(),
+  departmentDescription: z.string().trim(),
+  emailString: z.string().trim(),
+  employeeId: z.string().trim(),
+  extensionNumber: z.string().trim(),
+  firstName: z.string().trim(),
+  gender: z.string().trim(),
+  hiredDate: z.date(),
+  lastName: z.string().trim(),
+  managerId: z.string().trim(),
+  middleName: z.string().trim(),
+  name: z.string().trim(),
+  nameTitleCase: z.string().trim(),
+  nfcSn: z.string().trim(),
+  plantId: z.string().trim(),
+  position: z.string().trim(),
+  previousEmployeeIds: z.string().trim().nullable(),
+  reHiredDate: z.date().nullable(),
+  recordNumber: z.number(),
+  status: EmployeeStatus,
+  supervisorId: z.string().trim(),
+  terminationDate: z.date().nullable(),
+  terminationFutureDate: z.date().nullable(),
+  type: z.string().trim(),
+  upperDepartmentId: z.string().trim(),
+  jobCode: z.string().trim(),
+  jobDescription: z.string().trim(),
+  terminationReason: z.string().trim().nullable(),
+  supervisorRecordNumber: z.number(),
+});
+
+const DepartmentSchema = z.object({
+  departmentId: z.string().trim(),
+  description: z.string().trim(),
+  managerId: z.string().trim(),
+  managerRecordNumber: z.string().trim(),
+  treeLevel: z.number(),
+  upperDepartmentId: z.string().trim(),
+  companyCode: z.string().trim(),
+  location: z.string().trim(),
+  salLocation: z.string().trim(),
+  plantId: z.string().trim(),
+  manager: EmployeeSchema,
+});
+
+const EmployeeCategoryGroup = z.enum(["IDL", "FD", "FI"]);
+const EmployeeStatus = z.enum(["Active", "Terminated", "Leave of Absence"]);
+```
+
+## Examples
+
+```ts
+import { activeEmployeesQueryOptions } from "wcz-layout/data/client";
+import { getEmployeeManager } from "wcz-layout/data/server";
+
+// client
+const { data: employees = [] } = useQuery(activeEmployeesQueryOptions());
+
+// server
+const manager = await getEmployeeManager({ data: { employeeId } });
+```

package/skills/start/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: start
+description: Initialize a new project from the standard template
+---
+
+# Project Initialization Orchestrator
+
+## Role
+
+You are an AI assistant helping a developer bootstrap a new project from this template.
+
+## Execution Rules
+
+- Execute steps in order. Read **only** the current step file.
+- Pause whenever a step requires user input or a terminal command to finish.
+- Do not skip ahead or batch multiple steps.
+- When a step has branches (yes/no), follow only the matching branch.
+- To read a step, open the linked file in the **File** column directly.
+
+## Opening Message
+
+Begin every conversation with:
+
+> To make initialization flexible, you can choose:
+>
+> - ✅ **Full initialization** (recommended for new projects)
+> - ✅ **Partial / custom steps** (select specific steps below)
+
+Then list all steps by name so the user can pick.
+
+## Steps
+
+| #   | File                                                       | Summary                         |
+| --- | ---------------------------------------------------------- | ------------------------------- |
+| 1   | [01-git-setup.md](steps/01-git-setup.md)                   | Configure remote and branch     |
+| 2   | [02-project-name-setup.md](steps/02-project-name-setup.md) | Replace placeholder names       |
+| 3   | [03-apm-setup.md](steps/03-apm-setup.md)                   | Register the app internally     |
+| 4   | [04-database-setup.md](steps/04-database-setup.md)         | Postgres via Docker or existing |
+| 5   | [05-entra-setup.md](steps/05-entra-setup.md)               | Azure AD app registration       |
+| 6   | [06-vault-setup.md](steps/06-vault-setup.md)               | Vault secrets configuration     |
+| 7   | [07-generate-favicon.md](steps/07-generate-favicon.md)     | Generate and replace favicon    |
+| 8   | [08-commit.md](steps/08-commit.md)                         | Commit and push to origin       |
+
+## Completion
+
+After step 8 succeeds, the workflow ends — no further action needed.

package/skills/start/steps/01-git-setup.md

@@ -0,0 +1,10 @@
+# Git Setup
+
+## Actions
+
+1. Run `git remote -v`.
+   - **No remote exists** → ask for the repository URL, then run `git remote add origin <url>`.
+   - **Remote exists** → continue.
+2. Run `git branch --show-current`.
+   - **Not `master`** → run `git branch -M master`.
+   - **Already `master`** → continue.

package/skills/start/steps/02-project-name-setup.md

@@ -0,0 +1,14 @@
+# Project Name Setup
+
+## User Input
+
+Ask: **"What is your project name?"**
+
+## Actions
+
+Once provided, search-and-replace across the **entire workspace**:
+
+| Find           | Replace with                           |
+| -------------- | -------------------------------------- |
+| `project-name` | kebab-case version (e.g. `user-input`) |
+| `Project Name` | Title Case version (e.g. `User Input`) |