@itzworking/devkit 0.0.198-canary.20250707-e7f7621

package/dist-cjs/generate-api-clients/sync-api-clients.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncApiClients = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const syncApiClients = (webappDataPath) => {
+    const sourceDir = path.join(__dirname, "out", "apis");
+    const targetDir = path.join(webappDataPath, "apis");
+    if (!fs.existsSync(sourceDir)) {
+        throw new Error(`Source directory not found: ${sourceDir}`);
+    }
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    const getHooks = (dir) => {
+        const hooks = [];
+        const services = fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((dirent) => dirent.isDirectory() && dirent.name !== "node_modules");
+        for (const service of services) {
+            const hooksPath = path.join(dir, service.name, "hooks");
+            if (fs.existsSync(hooksPath)) {
+                const hookFiles = fs
+                    .readdirSync(hooksPath)
+                    .filter((file) => file.endsWith(".ts") && file !== "index.ts");
+                for (const hookFile of hookFiles) {
+                    hooks.push({
+                        service: service.name,
+                        name: hookFile.replace(".ts", ""),
+                        fullPath: path.join(hooksPath, hookFile),
+                    });
+                }
+            }
+        }
+        return hooks;
+    };
+    const existingHooks = getHooks(targetDir);
+    const newHooks = getHooks(sourceDir);
+    const addedHooks = newHooks.filter((newHook) => !existingHooks.some((existingHook) => existingHook.service === newHook.service &&
+        existingHook.name === newHook.name));
+    const removedHooks = existingHooks.filter((existingHook) => !newHooks.some((newHook) => newHook.service === existingHook.service &&
+        newHook.name === existingHook.name));
+    console.log("Hook changes:");
+    if (addedHooks.length === 0 && removedHooks.length === 0) {
+        console.log("No changes detected.");
+    }
+    addedHooks.forEach((hook) => console.log(`+ ${hook.service}/${hook.name}`));
+    removedHooks.forEach((hook) => console.log(`- ${hook.service}/${hook.name}`));
+    fs.copyFileSync(path.join(sourceDir, "api-client.ts"), path.join(targetDir, "api-client.ts"));
+    const services = fs
+        .readdirSync(sourceDir, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory());
+    const mainIndexContent = services
+        .map((service) => `export * from "./${service.name}";`)
+        .join("\n");
+    fs.writeFileSync(path.join(targetDir, "index.ts"), mainIndexContent);
+    for (const service of services) {
+        const sourceServiceDir = path.join(sourceDir, service.name);
+        const targetServiceDir = path.join(targetDir, service.name);
+        if (!fs.existsSync(targetServiceDir)) {
+            fs.mkdirSync(targetServiceDir, { recursive: true });
+        }
+        fs.copyFileSync(path.join(sourceServiceDir, `${service.name}-api.ts`), path.join(targetServiceDir, `${service.name}-api.ts`));
+        fs.copyFileSync(path.join(sourceServiceDir, "index.ts"), path.join(targetServiceDir, "index.ts"));
+        const targetHooksDir = path.join(targetServiceDir, "hooks");
+        if (!fs.existsSync(targetHooksDir)) {
+            fs.mkdirSync(targetHooksDir, { recursive: true });
+        }
+        const serviceHooks = [...addedHooks, ...existingHooks].filter((hook) => hook.service === service.name);
+        for (const hook of serviceHooks) {
+            const targetHookPath = path.join(targetHooksDir, `${hook.name}.ts`);
+            if (!fs.existsSync(targetHookPath)) {
+                fs.copyFileSync(hook.fullPath, targetHookPath);
+            }
+        }
+        const hooksIndexContent = serviceHooks
+            .map((hook) => `export * from "./${hook.name}";`)
+            .sort()
+            .join("\n") + "\n";
+        fs.writeFileSync(path.join(targetHooksDir, "index.ts"), hooksIndexContent);
+    }
+};
+exports.syncApiClients = syncApiClients;

package/dist-cjs/generate-api-clients/template-loader.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTemplate = loadTemplate;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+function loadTemplate(templateName) {
+    const possiblePaths = [
+        path.join(__dirname, "templates", templateName),
+        path.join(__dirname, "templates", templateName),
+        path.join(process.cwd(), "node_modules", "@itzworking", "devkit", "dist-cjs", "generate-api-clients", "templates", templateName),
+        path.join(process.cwd(), "node_modules", "@itzworking", "devkit", "dist-es", "generate-api-clients", "templates", templateName),
+    ];
+    for (const templatePath of possiblePaths) {
+        try {
+            if (fs.existsSync(templatePath)) {
+                return fs.readFileSync(templatePath, "utf8");
+            }
+        }
+        catch (error) {
+        }
+    }
+    throw new Error(`Template not found: ${templateName}. Tried paths: ${possiblePaths.join(", ")}`);
+}

package/dist-cjs/generate-api-clients/templates/api-client.hbs

@@ -0,0 +1,25 @@
+// prettier-ignore
+/* eslint-disable */
+
+import { ApiClientClass } from "../api-client";
+{{#each imports}}
+import { {{names}} } from "{{path}}";
+{{/each}}
+
+class {{className}}Class extends ApiClientClass {
+{{#each methods}}
+  async {{name}}({{params}}): Promise<{{returnType}}> {
+    {{#if outputType}}
+    const responseBody = await this.{{method}}({ path: {{{pathWithQuotes fullPath}}}{{#if inputType}}, options: { body }{{/if}} });
+    return new {{outputType.typeName}}(responseBody);
+    {{else}}
+    await this.{{method}}({ path: {{{pathWithQuotes fullPath}}}{{#if inputType}}, options: { body }{{/if}} });
+    {{/if}}
+  }
+{{#unless @last}}
+
+{{/unless}}
+{{/each}}
+}
+
+export const {{className}} = new {{className}}Class();

package/dist-cjs/generate-api-clients/templates/api-client.ts.template

@@ -0,0 +1,131 @@
+import {
+  del,
+  get,
+  head,
+  isCancelError,
+  patch,
+  post,
+  put,
+} from "aws-amplify/api";
+import type {
+  ApiInput as AmplifyApiInput,
+  RestApiOptionsBase as AmplifyRestApiOptionsBase,
+  RestApiResponse as AmplifyRestApiResponse,
+} from "@aws-amplify/api-rest/src/types";
+import { fetchAuthSession } from "aws-amplify/auth";
+
+type ApiClientInputOption = {
+  headers?: Record<string, string>;
+  queryParams?: Record<string, string>;
+  body?: any;
+};
+
+type ApiClientInput = {
+  path: string;
+  options?: Omit<ApiClientInputOption, "body">;
+};
+
+type ApiClientInputWithBody = {
+  path: string;
+  options?: ApiClientInputOption;
+};
+
+export type GetInput = ApiClientInputWithBody;
+export type PostInput = ApiClientInputWithBody;
+export type PutInput = ApiClientInputWithBody;
+export type PatchInput = ApiClientInputWithBody;
+export type DeleteInput = ApiClientInput;
+export type HeadInput = ApiClientInput;
+
+export class ApiClientClass {
+  private readonly apiName = "default";
+
+  private async formatInput(
+    input: ApiClientInput
+  ): Promise<AmplifyApiInput<AmplifyRestApiOptionsBase>> {
+    const { idToken, accessToken } = (await fetchAuthSession()).tokens ?? {};
+    return {
+      ...input,
+      apiName: this.apiName,
+      options: {
+        ...input.options,
+        headers: {
+          ...input.options?.headers,
+          Authorization: `Bearer ${idToken}`,
+        },
+      },
+    };
+  }
+
+  private async formatResponseBody(
+    response:
+      | Promise<AmplifyRestApiResponse>
+      | Promise<Omit<AmplifyRestApiResponse, "body">>
+  ): Promise<any> {
+    try {
+      const res = await response;
+      // Handle 204 No Content or empty body
+      if (res.statusCode === 204 || !("body" in res) || !res.body) {
+        return undefined;
+      }
+      // Try to parse JSON, but handle empty string
+      const text = await res.body.text();
+      if (!text) return undefined;
+      try {
+        const json = JSON.parse(text);
+        return json;
+      } catch (e) {
+        throw new Error("Response must be a JSON object or array");
+      }
+    } catch (e: any) {
+      if (e?._response?.body) {
+        let parsed: any;
+        try {
+          parsed = JSON.parse(e._response.body);
+        } catch (parseError) {
+          // If JSON parsing fails, continue to throw original error
+        }
+        if (parsed) {
+          throw parsed;
+        }
+      }
+      throw e;
+    }
+  }
+
+  async get(input: GetInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(get(formattedInput).response);
+  }
+
+  async put(input: PutInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(put(formattedInput).response);
+  }
+
+  async post(input: PostInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(post(formattedInput).response);
+  }
+
+  async delete(input: DeleteInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(del(formattedInput).response);
+  }
+
+  async head(input: HeadInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(head(formattedInput).response);
+  }
+
+  async patch(input: PatchInput) {
+    const formattedInput = await this.formatInput(input);
+    return this.formatResponseBody(patch(formattedInput).response);
+  }
+
+  isCancelError(error: unknown) {
+    return isCancelError(error);
+  }
+}
+
+export const ApiClient = new ApiClientClass();

package/dist-cjs/generate-api-clients/templates/hook-mutation.hbs

@@ -0,0 +1,39 @@
+// prettier-ignore
+/* eslint-disable */
+
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+{{#each imports}}
+import { {{names}} } from "{{path}}";
+{{/each}}
+
+export const {{hookName}} = () => {
+  const queryClient = useQueryClient();
+  const useMutationResult = useMutation({
+    mutationFn: ({{mutationParams}}){{#if outputType}}: Promise<{{outputType.typeName}}>{{/if}} => {{apiClassName}}.{{actionName}}({{#if mutationParams}}variables{{/if}}),
+    onMutate: async (variables) => {
+      // A mutation is about to happen!
+    },
+    onError: async (err, variables, context) => {
+      // An error happened!
+    },
+    onSuccess: async (data, variables, context) => {
+      // Boom baby!
+    },
+    onSettled: async () => {
+      // Error or success... doesn't matter!
+    }
+  });
+
+  return {
+    {{actionName}}: useMutationResult.mutate,
+    {{actionName}}Async: useMutationResult.mutateAsync,
+    is{{apiClassName}}Error: useMutationResult.isError,
+    is{{apiClassName}}Idle: useMutationResult.isIdle,
+    is{{apiClassName}}Paused: useMutationResult.isPaused,
+    is{{apiClassName}}Pending: useMutationResult.isPending,
+    is{{apiClassName}}Success: useMutationResult.isSuccess,
+    {{actionName}}Status: useMutationResult.status,
+    {{actionName}}Error: useMutationResult.error,
+    reset{{apiClassName}}: useMutationResult.reset
+  };
+};

package/dist-cjs/generate-api-clients/templates/hook-query.hbs

@@ -0,0 +1,28 @@
+// prettier-ignore
+/* eslint-disable */
+
+import { useQuery } from "@tanstack/react-query";
+{{#each imports}}
+import { {{names}} } from "{{path}}";
+{{/each}}
+
+export const {{relatedDataName}}QueryKey = ({{queryKeyParams}}) => [
+{{{queryKeyArray}}}
+];
+
+export const {{hookName}} = ({{queryKeyParams}}) => {
+  const useQueryResult = useQuery({
+    queryKey: {{relatedDataName}}QueryKey({{queryKeyInput}}),
+    queryFn: (){{#if outputType}}: Promise<{{outputType.typeName}}>{{/if}} => {{apiClassName}}.{{actionName}}({{queryKeyInput}})
+  });
+
+  return {
+    {{relatedDataName}}: useQueryResult.data,
+    {{relatedDataName}}UpdatedAt: useQueryResult.dataUpdatedAt,
+    {{actionName}}Error: useQueryResult.error,
+    is{{actionClassName}}Loading: useQueryResult.isLoading,
+    is{{actionClassName}}Fetching: useQueryResult.isFetching,
+    refetch{{actionClassName}}: useQueryResult.refetch,
+    {{actionName}}Status: useQueryResult.status
+  };
+};

package/dist-cjs/generate-api-clients/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-cjs/generate-api-clients/utils.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFile = exports.toFileName = exports.toClassName = exports.toPropertyName = exports.prepareImports = exports.getITzWorkingResources = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const getITzWorkingResources = ({ resourcesFilePath, }) => {
+    if (!fs.existsSync(resourcesFilePath)) {
+        console.error(`${resourcesFilePath} file not found. Please deploy your application.`);
+        process.exit(1);
+    }
+    const data = fs.readFileSync(resourcesFilePath, "utf-8");
+    try {
+        return JSON.parse(data);
+    }
+    catch (e) {
+        console.error(`Error parsing ${resourcesFilePath} file. Please ensure it is a valid JSON file.`);
+        process.exit(1);
+    }
+};
+exports.getITzWorkingResources = getITzWorkingResources;
+const prepareImports = (apis, options) => {
+    const formatedApis = Array.isArray(apis) ? apis : [apis];
+    const imports = [];
+    const importMap = {};
+    if (options.typeResolutionMode === "source-imports") {
+        for (const api of formatedApis) {
+            for (const [importPath, importNames] of Object.entries(api.imports)) {
+                if (!importMap[importPath])
+                    importMap[importPath] = new Set();
+                importNames.forEach((name) => importMap[importPath].add(name));
+            }
+        }
+    }
+    else if (options.typeResolutionMode === "inline-types") {
+        for (const api of formatedApis) {
+            const typeSpecs = [api.inputType, api.outputType];
+            for (const typeSpec of typeSpecs) {
+                if (!typeSpec || !typeSpec.importPath)
+                    continue;
+                if (!importMap["./types"])
+                    importMap["./types"] = new Set();
+                importMap["./types"].add(typeSpec.typeName);
+            }
+        }
+    }
+    else {
+        throw new Error(`Unsupported typeResolutionMode: ${options.typeResolutionMode}.`);
+    }
+    for (const importPath of Object.keys(importMap).sort()) {
+        imports.push({
+            path: importPath,
+            names: Array.from(importMap[importPath]).sort().join(", "),
+        });
+    }
+    return imports.sort((a, b) => b.path.localeCompare(a.path));
+};
+exports.prepareImports = prepareImports;
+const toPropertyName = (s) => {
+    return s
+        .replace(/([^a-zA-Z0-9])+(.)?/g, (_, __, chr) => chr ? chr.toUpperCase() : "")
+        .replace(/[^a-zA-Z\d]/g, "")
+        .replace(/^([A-Z])/, (m) => m.toLowerCase());
+};
+exports.toPropertyName = toPropertyName;
+const toClassName = (s) => {
+    const propertyName = (0, exports.toPropertyName)(s);
+    return propertyName.charAt(0).toUpperCase() + propertyName.slice(1);
+};
+exports.toClassName = toClassName;
+const toFileName = (s) => {
+    return s
+        .replace(/([a-z\d])([A-Z])/g, "$1_$2")
+        .toLowerCase()
+        .replace(/(?!^_)[ _]/g, "-");
+};
+exports.toFileName = toFileName;
+const writeFile = (params) => {
+    const { filePath, content, allowOverwrite } = params;
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    if (fs.existsSync(filePath) && !allowOverwrite) {
+        return;
+    }
+    fs.writeFileSync(filePath, content);
+};
+exports.writeFile = writeFile;

package/dist-cjs/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./generate-api-clients"), exports);

package/dist-es/generate-api-clients/api-type-spec-utils.js

@@ -0,0 +1,155 @@
+import { SyntaxKind, } from "ts-morph";
+function isDecoratedClass(classDecl) {
+    let current = classDecl;
+    while (current) {
+        const base = current.getBaseClass();
+        if (!base)
+            break;
+        if (base.getName() === "DecoratedClass") {
+            return true;
+        }
+        current = base;
+    }
+    return false;
+}
+function isZodSchema(varDecl) {
+    if (!varDecl)
+        return false;
+    const initializer = varDecl.getInitializer();
+    if (!initializer)
+        return false;
+    if (initializer.getKind() === SyntaxKind.CallExpression) {
+        const callExpr = initializer.asKind(SyntaxKind.CallExpression);
+        if (callExpr) {
+            const expr = callExpr.getExpression();
+            if (expr.getKind() === SyntaxKind.PropertyAccessExpression ||
+                expr.getKind() === SyntaxKind.Identifier) {
+                const exprText = expr.getText();
+                if (exprText.startsWith("z.")) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+export const setTypeKind = (type, sourceFile) => {
+    if (!type)
+        return;
+    let kind = type.kind;
+    const importSourceFile = type.importPath
+        ? sourceFile
+            .getImportDeclarations()
+            .find((d) => d.getModuleSpecifierValue() === type.importPath)
+            ?.getModuleSpecifierSourceFile()
+        : sourceFile;
+    const inputClass = importSourceFile?.getClass(type.typeName);
+    if (isDecoratedClass(inputClass)) {
+        kind = "decorated-class";
+    }
+    else {
+        const inputVar = importSourceFile?.getVariableDeclaration(type.typeName);
+        if (isZodSchema(inputVar)) {
+            kind = "zod-schema";
+        }
+    }
+    type.kind = kind;
+};
+export const extractTypeDefinition = (type, sourceFile) => {
+    if (!type?.importPath) {
+        return;
+    }
+    const importSourceFile = sourceFile
+        .getImportDeclarations()
+        .find((d) => d.getModuleSpecifierValue() === type.importPath)
+        ?.getModuleSpecifierSourceFile();
+    if (!importSourceFile) {
+        throw new Error(`Could not find import source file for path: ${type.importPath}`);
+    }
+    const allowedImportLibraries = [
+        "@itzworking/decorated-class",
+        "zod",
+        "zod/v4",
+    ];
+    const allowedImports = [];
+    const inlinedFiles = [];
+    const filesToProcess = [importSourceFile];
+    const processedFiles = new Set();
+    while (filesToProcess.length > 0) {
+        const currentSourceFile = filesToProcess.pop();
+        if (currentSourceFile === undefined) {
+            console.log("Source file is undefined, skipping...");
+            continue;
+        }
+        const filePath = currentSourceFile.getFilePath();
+        if (processedFiles.has(filePath)) {
+            continue;
+        }
+        processedFiles.add(filePath);
+        for (const importDeclarations of currentSourceFile.getImportDeclarations()) {
+            const moduleSpecifier = importDeclarations
+                .getModuleSpecifier()
+                .getLiteralValue();
+            if (allowedImportLibraries.includes(moduleSpecifier)) {
+                const namespaceImport = importDeclarations
+                    .getNamespaceImport()
+                    ?.getText();
+                if (namespaceImport) {
+                    const currentNamespaceImport = allowedImports.find((i) => i.namespaceImport && i.importPath === moduleSpecifier);
+                    if (!currentNamespaceImport) {
+                        allowedImports.push({
+                            namespaceImport: true,
+                            importPath: moduleSpecifier,
+                            importNames: new Set([namespaceImport]),
+                        });
+                    }
+                    else {
+                        currentNamespaceImport.importNames.add(namespaceImport);
+                    }
+                }
+                else {
+                    let currentImport = allowedImports.find((i) => !i.namespaceImport && i.importPath === moduleSpecifier);
+                    if (!currentImport) {
+                        currentImport = {
+                            namespaceImport: false,
+                            importPath: moduleSpecifier,
+                            importNames: new Set(),
+                        };
+                        allowedImports.push(currentImport);
+                    }
+                    for (const namedImport of importDeclarations.getNamedImports()) {
+                        currentImport.importNames.add(namedImport.getName());
+                    }
+                }
+            }
+            else {
+                const importedSourceFile = importDeclarations.getModuleSpecifierSourceFile();
+                const importedFilePath = importedSourceFile?.getFilePath();
+                if (!importedSourceFile || !importedFilePath) {
+                    continue;
+                }
+                if (!processedFiles.has(importedFilePath)) {
+                    filesToProcess.push(importedSourceFile);
+                }
+            }
+        }
+        let text = currentSourceFile.getFullText();
+        const importDeclarations = currentSourceFile.getImportDeclarations();
+        for (const importDecl of importDeclarations.reverse()) {
+            const start = importDecl.getStart();
+            const end = importDecl.getEnd();
+            text = (text.slice(0, start) + text.slice(end)).trim();
+        }
+        inlinedFiles.push({
+            filePath: filePath,
+            text,
+        });
+    }
+    type.typeDefinition = {
+        allowedImports: allowedImports.map((i) => ({
+            ...i,
+            importNames: Array.from(i.importNames),
+        })),
+        inlinedFiles: inlinedFiles.reverse(),
+    };
+};

package/dist-es/generate-api-clients/copy-api-client.js

@@ -0,0 +1,12 @@
+import { writeFile } from "./utils";
+import { loadTemplate } from "./template-loader";
+import * as path from "path";
+export const copyApiClient = (options) => {
+    const apiClientContent = loadTemplate("api-client.ts.template");
+    writeFile({
+        filePath: path.join(options.outputDirectory, "api-client.ts"),
+        content: apiClientContent,
+        allowOverwrite: options.allowOverwrite,
+        verbose: options.verbose,
+    });
+};