phorge 0.1.0

package/src/models/project.ts

@@ -0,0 +1,100 @@
+import { type ApiResponse, CreateObjectResult, type PHID, type Policy } from "./phorge.js"
+import * as z from "zod"
+
+export const Icon = z.object({
+    key: z.string(),
+    name: z.string(),
+    icon: z.string()
+})
+
+export type Icon = z.infer<typeof Icon>
+
+export const Color = z.object({
+    key: z.string(),
+    mame: z.string(),
+})
+
+export type Color = z.infer<typeof Color>
+
+export const ProjectTransaction = z.object({
+    parent: z.custom<PHID<"PROJ">>().optional(),
+    milestone: z.custom<PHID<"PROJ">>().optional(),
+    space: z.unknown().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    color: z.string().optional(),
+    slugs: z.string().array().nonempty().optional(),
+    members: z.object({
+        add: z.custom<PHID<"USER">>().array().nonempty().optional(),
+        remove: z.custom<PHID<"USER">>().array().nonempty().optional(),
+        set: z.custom<PHID<"USER">>().array().nonempty().optional()
+    }).optional(),
+    view: z.custom<PHID<"PLCY">>().or(z.enum(["obj.project.members", "users", "admin", "no-one"])).optional(), // TODO, Check Policy ID, and policy constant
+    edit: z.custom<PHID<"PLCY">>().or(z.enum(["obj.project.members", "users", "admin", "no-one"])).optional(), // TODO, Check Policy ID, and policy constant
+    join: z.custom<PHID<"PLCY">>().or(z.enum(["obj.project.members", "users", "admin", "no-one"])).optional(), // TODO, Check Policy ID, and policy constant
+    subtype: z.string().optional(),
+    mfa: z.boolean().optional()
+})
+
+export type ProjectTransaction = z.infer<typeof ProjectTransaction>
+
+export const ProjectConstraints = z.object({
+    ids: z.number().array().nonempty().optional(),
+    phids: z.custom<PHID<"PROJ">>().array().nonempty().optional(),
+    slugs: z.string().array().nonempty().optional(),
+    members: z.custom<PHID<"USER">>().array().nonempty().optional(),
+    watchers: z.custom<PHID<"USER">>().array().nonempty().optional(),
+    status: z.enum(["active", "archived", "all"]).optional(),
+    isMilestone: z.boolean().optional(),
+    isRoot: z.boolean().optional(),
+    minDepth: z.number().optional(),
+    maxDepth: z.number().optional(),
+    subtypes: z.string().array().nonempty().optional(),
+    icons: z.string().array().nonempty().optional(),
+    colors: z.string().array().nonempty().optional(),
+    parents: z.custom<PHID<"PROJ">>().array().optional(),
+    ancestors: z.custom<PHID<"PROJ">>().array().optional(),
+    query: z.string().optional()
+})
+
+export type ProjectConstraints = z.infer<typeof ProjectConstraints>
+
+export const ProjectSearchOptions = z.object({
+    queryKey: z.string().optional(),
+    constraints: z.custom<ProjectConstraints>().optional(),
+    attachments: z.unknown().optional(),
+    order: z.enum(["priority", "updated", "outdated", "newest", "oldest", "closed", "title", "relevance"]).optional(),
+    before: z.number().optional(),
+    after: z.number().optional(),
+    limit: z.number().optional()
+})
+
+export type ProjectSearchOptions = z.infer<typeof ProjectSearchOptions>
+
+export const SearchProjectResult = z.object({
+    id: z.number(),
+    type: z.custom<"PROJ">(),
+    phid: z.custom<PHID<"PROJ">>(),
+    fields: z.object({
+        name: z.string(),
+        slug: z.string(),
+        subtype: z.string(),
+        milestone: z.unknown(),
+        depth: z.number(),
+        parent: z.custom<PHID<"PROJ">>(),
+        icon: z.custom<Icon>(),
+        color: z.custom<Color>(),
+        status: z.enum(["active", "archived", "all"]),
+        spacePHID: z.custom<PHID<"SPCE">>(),
+        dateCreated: z.number(),
+        dateModified: z.number(),
+        policy: z.custom<Policy>(),
+        description: z.string()
+    })
+}) 
+
+export type SearchProjectResult = z.infer<typeof SearchProjectResult>
+
+export type CreateProjectResponse = ApiResponse<{ object: CreateObjectResult }>
+export type SearchProjectResponse = ApiResponse<{ data: SearchProjectResult[] }>

package/src/models/transaction.ts

@@ -0,0 +1,49 @@
+import * as z from "zod";
+import { ObjectType, type ApiResponse, type PHID } from "./phorge.js";
+
+export const TransactionConstraints = z.object({
+    phids: z.custom<PHID>().array().optional(),
+    authorPHIDs: z.custom<PHID<"USER">>().array().optional()
+})
+
+export type TransactionConstraints = z.infer<typeof TransactionConstraints>
+
+export const TransactionSearchOptions = z.object({
+    objectIdentifier: z.custom<PHID>().optional(),
+    objectType: ObjectType.optional(),
+    constraints: z.custom<TransactionConstraints>().optional(),
+    before: z.number().optional(),
+    after: z.number().optional(),
+    limit: z.number().optional()
+})
+
+export type TransactionSearchOptions = z.infer<typeof TransactionSearchOptions>
+
+export const TransactionComment = z.object({
+    id: z.number(),
+    phid: z.string(),
+    version: z.number(),
+    authorPHID: z.custom<PHID<"USER">>(),
+    dateCreated: z.number(),
+    dateModified: z.number(),
+    removed: z.boolean(),
+    content: z.object({ raw: z.string() })
+})
+
+export type TransactionComment = z.infer<typeof TransactionComment>
+
+export const SearchTransactionResult = z.object({
+    id: z.number(),
+    phid: z.string(),
+    type: z.string().nullable(),
+    authorPHID: z.custom<PHID<"USER">>(),
+    objectPHID: z.custom<PHID>(),
+    dateCreated: z.number(),
+    dateModified: z.number(),
+    groupID: z.string(),
+    comments: TransactionComment.array()
+}).array();
+
+export type SearchTransactionResult = z.infer<typeof SearchTransactionResult>
+
+export type SearchTransactionResponse = ApiResponse<{ data: SearchTransactionResult[] }>

package/src/models/user.ts

@@ -0,0 +1,55 @@
+import * as z from "zod"
+import type { ApiResponse, CreateObjectResult, PHID } from "./phorge.js"
+
+export const UserConstraints = z.object({
+    ids: z.number().array().nonempty().optional(),
+    phids: z.custom<PHID<"USER">>().array().nonempty().optional(),
+    usernames: z.string().array().nonempty().optional(),
+    nameLike: z.string().nonempty().optional(),
+    isAdmin: z.boolean().optional(),
+    isDisabled: z.boolean().optional(),
+    isBot: z.boolean().optional(),
+    isMailingList: z.boolean().optional(),
+    needsApproval: z.boolean().optional(),
+    mfa: z.boolean().optional(),
+    createdStart: z.number().optional(),
+    createdEnd: z.number().optional(),
+    query: z.string().nonempty().optional()
+})
+
+export type UserConstraints = z.infer<typeof UserConstraints>
+
+export const UserSearchOptions = z.object({
+    queryKey: z.string().optional(),
+    constraints: z.custom<UserConstraints>().optional(),
+    attachments: z.unknown().optional(),
+    order: z.enum(["priority", "updated", "outdated", "newest", "oldest", "closed", "title", "relevance"]).optional(),
+    before: z.number().optional(),
+    after: z.number().optional(),
+    limit: z.number().optional()
+})
+
+export type UserSearchOptions = z.infer<typeof UserSearchOptions>
+
+export const SearchUserResult = z.object({
+    id: z.number(),
+    type: z.literal("USER"),
+    phid: z.custom<PHID<"USER">>(),
+    fields: z.object({
+        username: z.string(),
+        realName: z.string(),
+        roles: z.string().array(),
+        dateCreated: z.number(),
+        dateModified: z.number(),
+        policy: z.object({
+            view: z.string(),
+            edit: z.string()
+        })
+    }),
+    attachments: z.unknown()
+}).array()
+
+export type SearchUserResult = z.infer<typeof SearchUserResult>
+
+export type CreateUserResponse = ApiResponse<{ object: CreateObjectResult }>
+export type SearchUserResponse = ApiResponse<{ data: SearchUserResult }>

package/src/utils.ts

@@ -0,0 +1,59 @@
+export function ConstraintObjectToParams(obj: Record<string, any>, prefix = ""): URLSearchParams {
+    const params = new URLSearchParams();
+    for (const [k, v] of Object.entries(obj)) {
+        console.log(k, v)
+        if (Array.isArray(v)) {
+            let index = 0;
+            v.forEach((item: string, j: number) => {
+                const itemVal = typeof item === "string" ? item : JSON.stringify(item);
+                params.append(`constraints[${k}][${index}]`, itemVal);
+                index++;
+            });
+        } else {
+            const value = typeof v === "string" ? v : JSON.stringify(v);
+            params.append(`constraints[${k}]`, value);
+        }
+    }
+    return params;
+}
+
+export function TransactionObjectToParams(obj: Record<string, any>, prefix = ""): URLSearchParams {
+    const params = new URLSearchParams();
+    let index = 0;
+    for (const [k, v] of Object.entries(obj)) {
+        let val = v
+        let key = k;
+
+        if (["parents", "subtasks", "commits", "projects", "subscribers", "members"].includes(key)) {
+            if (Object.keys(v).includes("add")) {
+                key = `${key}.add`
+                val = val["add"]
+            } else if (Object.keys(v).includes("remove")) {
+                key = `${key}.remove`
+                val = val["remove"]
+            } else if (Object.keys(v).includes("set")) {
+                key = `${key}.set`
+                val = val["set"]
+            }
+        }
+
+        const typeKey = `transactions[${index}][type]`;
+        const valueKey = `transactions[${index}][value]`;
+
+        params.append(typeKey, key);
+
+        if (Array.isArray(val)) {
+            val.forEach((item: string, j: number) => {
+                const itemKey = `${valueKey}[${j}]`;
+                const itemVal = typeof item === "string" ? item : JSON.stringify(item);
+                params.append(itemKey, itemVal);
+            });
+        } else {
+            const value = typeof v === "string" ? v : JSON.stringify(v);
+            params.append(valueKey, value);
+        }
+
+        index++;
+    }
+    return params;
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}