@intrig/plugin-react 0.0.1 → 0.0.2-2

package/src/lib/templates/source/controller/method/requestHook.template.ts

@@ -1,220 +0,0 @@
-import {
-  camelCase,
-  generatePostfix,
-  pascalCase, ResourceDescriptor, RestData,
-  typescript,
-  Variable
-} from "@intrig/plugin-sdk";
-import * as path from 'path';
-import {InternalGeneratorContext} from "../../../../internal-types.js";
-
-function extractHookShapeAndOptionsShape(response: string | undefined, requestBody: string | undefined, imports: Set<string>) {
-  if (response) {
-    if (requestBody) {
-      imports.add(`import { BinaryFunctionHook, BinaryHookOptions } from "@intrig/react"`);
-      return {
-        hookShape: `BinaryFunctionHook<Params, RequestBody, Response>`,
-        optionsShape: `BinaryHookOptions<Params, RequestBody>`
-      };
-    } else {
-      imports.add(`import { UnaryFunctionHook, UnaryHookOptions } from "@intrig/react"`);
-      return {
-        hookShape: `UnaryFunctionHook<Params, Response>`,
-        optionsShape: `UnaryHookOptions<Params>`
-      };
-    }
-  } else {
-    if (requestBody) {
-      imports.add(`import { BinaryProduceHook, BinaryHookOptions } from "@intrig/react"`);
-      return {
-        hookShape: `BinaryProduceHook<Params, RequestBody>`,
-        optionsShape: `BinaryHookOptions<Params, RequestBody>`
-      };
-    } else {
-      imports.add(`import { UnaryProduceHook, UnaryHookOptions } from "@intrig/react"`);
-      return {
-        hookShape: `UnaryProduceHook<Params>`,
-        optionsShape: `UnaryHookOptions<Params>`
-      };
-    }
-  }
-}
-
-function extractParamDeconstruction(variables: Variable[], requestBody?: string) {
-  const isParamMandatory = variables?.some(a => a.in === 'path') || false;
-
-  if (requestBody) {
-    if (isParamMandatory) {
-      return {
-        paramExpression: 'data, p',
-        paramType: 'data: RequestBody, params: Params'
-      }
-    } else {
-      return {
-        paramExpression: 'data, p = {}',
-        paramType: 'data: RequestBody, params?: Params'
-      }
-    }
-  } else {
-    if (isParamMandatory) {
-      return {
-        paramExpression: 'p',
-        paramType: 'params: Params'
-      }
-    } else {
-      return {
-        paramExpression: 'p = {}',
-        paramType: 'params?: Params'
-      }
-    }
-  }
-}
-
-function extractErrorParams(errorTypes: string[]) {
-  switch (errorTypes.length) {
-    case 0:
-      return `
-      export type _ErrorType = any
-      const errorSchema = z.any()`
-    case 1:
-      return `
-      export type _ErrorType = ${errorTypes[0]}
-      const errorSchema = ${errorTypes[0]}Schema`
-    default:
-      return `
-      export type _ErrorType = ${errorTypes.join(' | ')}
-      const errorSchema = z.union([${errorTypes.map(a => `${a}Schema`).join(', ')}])`
-  }
-}
-
-export async function requestHookTemplate({source,
-                                                 data: {
-                                                   paths,
-                                                   operationId,
-                                                   response,
-                                                   requestUrl,
-                                                   variables,
-                                                   requestBody,
-                                                   contentType,
-                                                   responseType,
-                                                   errorResponses,
-                                                   method
-                                                 }
-                                               }: ResourceDescriptor<RestData>, ctx: InternalGeneratorContext) {
-  const postfix = ctx.potentiallyConflictingDescriptors.includes(operationId) ? generatePostfix(contentType, responseType) : ''
-  const ts = typescript(path.resolve('src', source, ...paths, camelCase(operationId), `use${pascalCase(operationId)}${postfix}.ts`))
-  ctx.getCounter(source)?.inc("Stateful Hooks")
-
-  const modifiedRequestUrl = `${requestUrl?.replace(/\{/g, "${")}`
-
-  const imports = new Set<string>();
-  imports.add(`import { z } from 'zod'`)
-  imports.add(`import { useCallback, useEffect } from 'react'`)
-  imports.add(`import {useNetworkState, NetworkState, DispatchState, error, successfulDispatch, validationError, encode, requestValidationError} from "@intrig/react"`)
-
-  const { hookShape, optionsShape } = extractHookShapeAndOptionsShape(response, requestBody, imports);
-
-  const { paramExpression, paramType } = extractParamDeconstruction(variables ?? [], requestBody);
-
-  if (requestBody) {
-    imports.add(`import { ${requestBody} as RequestBody, ${requestBody}Schema as requestBodySchema } from "@intrig/react/${source}/components/schemas/${requestBody}"`)
-  }
-
-  if (response) {
-    imports.add(`import { ${response} as Response, ${response}Schema as schema } from "@intrig/react/${source}/components/schemas/${response}"`)
-  }
-
-  imports.add(`import {${pascalCase(operationId)}Params as Params} from './${pascalCase(operationId)}.params'`)
-
-  const errorTypes = [...new Set(Object.values(errorResponses ?? {}).map(a => a.response))]
-  errorTypes.forEach(ref => imports.add(`import {${ref}, ${ref}Schema } from "@intrig/react/${source}/components/schemas/${ref}"`))
-
-  const paramExplode = [
-    ...variables?.filter(a => a.in === "path").map(a => a.name) ?? [],
-    "...params"
-  ].join(",")
-
-  const finalRequestBodyBlock = requestBody ? `,data: encode(data, "${contentType}", requestBodySchema)` : ''
-
-  function responseTypePart() {
-    switch (responseType) {
-      case "application/octet-stream":
-        return `responseType: 'blob', adapter: 'fetch',`;
-      case "text/event-stream":
-        return `responseType: 'stream', adapter: 'fetch',`;
-    }
-    return ''
-  }
-
-  return ts`
-    ${[...imports].join('\n')}
-
-    ${!response ? `
-    type Response = any;
-    const schema = z.any();
-    ` : ''}
-
-    ${extractErrorParams(errorTypes.map(a => a as string))}
-
-    const operation = "${method.toUpperCase()} ${requestUrl}| ${contentType} -> ${responseType}"
-    const source = "${source}"
-
-    function use${pascalCase(operationId)}Hook(options: ${optionsShape} = {}): [NetworkState<Response>, (${paramType}) => DispatchState<any>, () => void] {
-      const [state, dispatch, clear, dispatchState] = useNetworkState<Response>({
-        key: options?.key ?? 'default',
-        operation,
-        source,
-        schema,
-        errorSchema
-      });
-
-      const doExecute = useCallback<(${paramType}) => DispatchState<any>>((${paramExpression}) => {
-        const { ${paramExplode}} = p
-
-          ${requestBody ? `
-          const validationResult = requestBodySchema.safeParse(data);
-          if (!validationResult.success) {
-            dispatchState(error(requestValidationError(validationResult.error)));
-            return validationError(validationResult.error.errors);
-          }
-          ` : ``}
-
-          dispatch({
-            method: '${method}',
-            url: \`${modifiedRequestUrl}\`,
-            headers: {
-              ${contentType ? `"Content-Type": "${contentType}",` : ''}
-            },
-            params,
-            key: \`${"${source}: ${operation}"}\`,
-            source: '${source}'
-            ${requestBody ? finalRequestBodyBlock : ''},
-            ${(responseTypePart())}
-          })
-          return successfulDispatch();
-      }, [dispatch])
-
-      useEffect(() => {
-        if (options.fetchOnMount) {
-          doExecute(${[requestBody ? `options.body!` : undefined, "options.params!"].filter(a => a).join(",")});
-        }
-
-        return () => {
-          if (options.clearOnUnmount) {
-            clear();
-          }
-        }
-      }, [])
-
-      return [
-        state,
-        doExecute,
-        clear
-      ]
-    }
-
-    use${pascalCase(operationId)}Hook.key = \`${"${source}: ${operation}"}\`
-
-    export const use${pascalCase(operationId)}: ${hookShape} = use${pascalCase(operationId)}Hook;
-  `
-}

package/src/lib/templates/source/type/typeTemplate.ts

@@ -1,257 +0,0 @@
-import { OpenAPIV3_1 } from 'openapi-types';
-import {jsonLiteral, ResourceDescriptor, Schema, typescript} from "@intrig/plugin-sdk";
-import * as path from 'path'
-
-export interface SchemaConversionResult {
-  tsType: string;
-  zodSchema: string;
-  imports: Set<string>;
-  optional?: boolean;
-  binaryish?: boolean;
-}
-
-export async function typeTemplate(descriptor: ResourceDescriptor<Schema>) {
-
-  const {
-    data: {
-      schema,
-      name: typeName
-    },
-    source
-  } = descriptor;
-
-  const {imports, zodSchema, tsType} = openApiSchemaToZod(schema);
-
-  const ts = typescript(path.resolve('src', source, 'components', 'schemas', `${typeName}.ts`));
-
-  const simpleType = (await jsonLiteral('')`${JSON.stringify(schema)}`).content;
-
-  const transport =
-    schema.type === 'string' && (schema as any).format === 'binary'
-      ? 'binary'
-      : 'json';
-
-  return ts`
-  import { z } from 'zod'
-
-  ${[...imports].join('\n')}
-
-  //--- Zod Schemas  ---//
-
-  export const ${typeName}Schema = ${zodSchema}
-
-  //--- Typescript Type  ---//
-
-  export type ${typeName} = ${tsType}
-
-  //--- JSON Schema  ---//
-
-  export const ${typeName}_jsonschema = ${JSON.stringify(schema) ?? "{}"}
-
-  //--- Simple Type  ---//
-  /*[${simpleType}]*/
-  
-  // Transport hint for clients ("binary" => use arraybuffer/blob)
-  export const ${typeName}_transport = '${transport}' as const;
-  `
-}
-
-function isRef(schema: OpenAPIV3_1.SchemaObject | OpenAPIV3_1.ReferenceObject): schema is OpenAPIV3_1.ReferenceObject {
-  return  '$ref' in (schema ?? {});
-}
-
-// Helper function to convert OpenAPI schema types to TypeScript types and Zod schemas
-export function openApiSchemaToZod(schema: OpenAPIV3_1.SchemaObject, imports: Set<string> = new Set()): SchemaConversionResult {
-  if (!schema) {
-    return { tsType: 'any', zodSchema: 'z.any()', imports: new Set() };
-  }
-  if (isRef(schema)) {
-    return handleRefSchema(schema.$ref, imports);
-  }
-
-  if (!schema.type) {
-    if ('properties' in schema) {
-      schema.type = 'object';
-    } else if ('items' in schema) {
-      schema.type = 'array' as any;
-    }
-  }
-
-  switch (schema.type) {
-    case 'string':
-      return handleStringSchema(schema);
-    case 'number':
-      return handleNumberSchema(schema);
-    case 'integer':
-      return handleIntegerSchema(schema);
-    case 'boolean':
-      return handleBooleanSchema();
-    case 'array':
-      return handleArraySchema(schema, imports);
-    case 'object':
-      return handleObjectSchema(schema, imports);
-    default:
-      return handleComplexSchema(schema, imports);
-  }
-}
-
-function handleRefSchema(ref: string, imports: Set<string>): SchemaConversionResult {
-  const refParts = ref.split('/');
-  const refName = refParts[refParts.length - 1];
-  imports.add(`import { ${refName}, ${refName}Schema } from './${refName}';`);
-  return { tsType: refName, zodSchema: `z.lazy(() => ${refName}Schema)`, imports };
-}
-
-function handleStringSchema(schema: OpenAPIV3_1.SchemaObject): SchemaConversionResult {
-  const imports = new Set<string>();
-  let binaryish = false;
-  if (schema.enum) {
-    const enumValues = schema.enum.map(value => `'${value}'`).join(' | ');
-    const zodEnum = `z.enum([${schema.enum.map(value => `'${value}'`).join(', ')}])`;
-    return { tsType: enumValues, zodSchema: zodEnum , imports: new Set() };
-  }
-
-  let zodSchema = 'z.string()';
-  let tsType = 'string';
-
-  if (schema.format === 'date' && !schema.pattern) {
-    tsType = 'Date';
-    zodSchema = 'z.coerce.date()';
-    zodSchema += `.transform((val) => {
-        const parsedDate = new Date(val);
-        if (isNaN(parsedDate.getTime())) {
-          throw new Error('Invalid date format');
-        }
-        return parsedDate;
-    })`;
-  } else if (schema.format === 'time') {
-    zodSchema = 'z.string()';
-    if (schema.pattern) {
-      zodSchema += `.regex(new RegExp('${schema.pattern}'))`;
-    }
-  } else if (schema.format === 'date-time' && !schema.pattern) {
-    tsType = 'Date';
-    zodSchema = 'z.coerce.date()';
-    zodSchema += `.transform((val) => {
-        const parsedDateTime = new Date(val);
-        if (isNaN(parsedDateTime.getTime())) {
-          throw new Error('Invalid date-time format');
-        }
-        return parsedDateTime;
-    })`;
-  } else if (schema.format === 'binary') {
-    tsType = 'BinaryData';
-    zodSchema = 'BinaryDataSchema';
-    imports.add(`import { BinaryData, BinaryDataSchema } from '@intrig/react/type-utils'`);
-    binaryish = true;
-  } else if (schema.format === 'byte') {
-    tsType = 'Uint8Array';
-    zodSchema = 'z.string().transform((val) => base64ToUint8Array(val))';
-    imports.add(`import { base64ToUint8Array } from '@intrig/react/type-utils'`);
-    binaryish = true;
-  } else if (schema.format === 'email') {
-    zodSchema = 'z.string().email()';
-  } else if (schema.format === 'uuid') {
-    zodSchema = 'z.string().uuid()';
-  } else if (schema.format === 'uri') {
-    zodSchema = 'z.string().url()';
-  } else if (schema.format === 'hostname') {
-    zodSchema = 'z.string()'; // Zod does not have a direct hostname validator
-  } else if (schema.format === 'ipv4') {
-    zodSchema =  'z.string().regex(/^((25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[0-1]?[0-9][0-9]?)$/)';
-  } else if (schema.format === 'ipv6') {
-    zodSchema = 'z.string().regex(/^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6}|:)|::(ffff(:0{1,4}){0,1}:)?((25[0-5]|(2[0-4]|1[0-9]|[0-9])\\.){3}(25[0-5]|(2[0-4]|1[0-9]|[0-9]))))$/)';
-  } else {
-    if (schema.minLength !== undefined) zodSchema += `.min(${schema.minLength})`;
-    if (schema.maxLength !== undefined) zodSchema += `.max(${schema.maxLength})`;
-    if (schema.pattern !== undefined) zodSchema += `.regex(new RegExp('${schema.pattern}'))`;
-  }
-  return { tsType, zodSchema, imports, binaryish };
-}
-
-function handleNumberSchema(schema: OpenAPIV3_1.SchemaObject): SchemaConversionResult {
-  let zodSchema = 'z.number()';
-  if (schema.minimum !== undefined) zodSchema += `.min(${schema.minimum})`;
-  if (schema.maximum !== undefined) zodSchema += `.max(${schema.maximum})`;
-  return { tsType: 'number', zodSchema, imports: new Set() };
-}
-
-function handleIntegerSchema(schema: OpenAPIV3_1.SchemaObject): SchemaConversionResult {
-  let zodSchema = 'z.number().int()';
-  if (schema.minimum !== undefined) zodSchema += `.min(${schema.minimum})`;
-  if (schema.maximum !== undefined) zodSchema += `.max(${schema.maximum})`;
-  return { tsType: 'number', zodSchema, imports: new Set() };
-}
-
-function handleBooleanSchema(): SchemaConversionResult {
-  const zodSchema = 'z.boolean()';
-  return { tsType: 'boolean', zodSchema, imports: new Set() };
-}
-
-function handleArraySchema(schema: OpenAPIV3_1.ArraySchemaObject, imports: Set<string>): SchemaConversionResult {
-  if (!schema.items) {
-    throw new Error('Array schema must have an items property');
-  }
-
-  const {
-    tsType,
-    zodSchema: itemZodSchema,
-    imports: itemImports,
-    binaryish
-  } = openApiSchemaToZod(schema.items as OpenAPIV3_1.SchemaObject, imports);
-
-  let zodSchema = binaryish ?
-    `z.array(${itemZodSchema})`:
-    `(z.preprocess((raw) => (Array.isArray(raw) ? raw : [raw]), z.array(${itemZodSchema})) as z.ZodType<${tsType}[], z.ZodTypeDef, ${tsType}[]>)`;
-  if (schema.minItems !== undefined) zodSchema += `.min(${schema.minItems})`;
-  if (schema.maxItems !== undefined) zodSchema += `.max(${schema.maxItems})`;
-  return {tsType: `(${tsType})[]`, zodSchema, imports: new Set([...imports, ...itemImports])};
-}
-
-function handleObjectSchema(schema: OpenAPIV3_1.SchemaObject, imports: Set<string>): SchemaConversionResult {
-  const updatedRequiredFields = schema.required || [];
-  if (schema.properties) {
-    const propertiesTs = Object.entries(schema.properties).map(([key, value]) => {
-      const { tsType, optional } = openApiSchemaToZod(value as OpenAPIV3_1.SchemaObject);
-      const isRequired = !optional && updatedRequiredFields.includes(key);
-      return `${key}${isRequired ? '' : '?'}: ${tsType} ${isRequired ? '' : ' | null'};`;
-    });
-
-    const propertiesZod = Object.entries(schema.properties).map(([key, value]) => {
-      const { zodSchema, imports: propImports } = openApiSchemaToZod(value as OpenAPIV3_1.SchemaObject);
-      imports = new Set([...imports, ...propImports]);
-      const isRequired = updatedRequiredFields.includes(key);
-      return `${key}: ${isRequired ? zodSchema : zodSchema.includes('.optional().nullable()') ? zodSchema : zodSchema + '.optional().nullable()'}`;
-    });
-
-    return {
-      tsType: `{ ${propertiesTs.join(' ')} }`,
-      zodSchema: `z.object({ ${propertiesZod.join(', ')} })`,
-      imports,
-    };
-  }
-  return { tsType: 'any', zodSchema: 'z.any()', imports: new Set(), optional: true };
-}
-
-function handleComplexSchema(schema: OpenAPIV3_1.SchemaObject, imports: Set<string>): SchemaConversionResult {
-  if (schema.oneOf) {
-    const options = schema.oneOf.map(subSchema => openApiSchemaToZod(subSchema as OpenAPIV3_1.SchemaObject));
-    const zodSchemas = options.map(option => option.zodSchema);
-    const tsTypes = options.map(option => option.tsType);
-    return { tsType: tsTypes.join(' | '), zodSchema: `z.union([${zodSchemas.join(', ')}])`, imports: new Set([...imports, ...options.flatMap(option => Array.from(option.imports))]) };
-  }
-  if (schema.anyOf) {
-    const options = schema.anyOf.map(subSchema => openApiSchemaToZod(subSchema as OpenAPIV3_1.SchemaObject));
-    const zodSchemas = options.map(option => option.zodSchema);
-    const tsTypes = options.map(option => option.tsType);
-    return { tsType: tsTypes.join(' | '), zodSchema: `z.union([${zodSchemas.join(', ')}])`, imports: new Set([...imports, ...options.flatMap(option => Array.from(option.imports))]) };
-  }
-  if (schema.allOf) {
-    const options = schema.allOf.map(subSchema => openApiSchemaToZod(subSchema as OpenAPIV3_1.SchemaObject));
-    const zodSchemas = options.map(option => option.zodSchema);
-    const tsTypes = options.map(option => option.tsType);
-    if (zodSchemas.length === 1) return { tsType: tsTypes.join(' & '), zodSchema: zodSchemas[0], imports: new Set([...imports, ...options.flatMap(option => Array.from(option.imports))]) };
-    return { tsType: tsTypes.join(' & '), zodSchema: `z.intersection(${zodSchemas.join(', ')})`, imports: new Set([...imports, ...options.flatMap(option => Array.from(option.imports))]) };
-  }
-  return { tsType: 'any', zodSchema: 'z.any()', imports };
-}

package/src/lib/templates/swcrc.template.ts

@@ -1,25 +0,0 @@
-import {jsonLiteral} from "@intrig/plugin-sdk";
-import * as path from "path";
-
-export function reactSwcrcTemplate() {
-  const json = jsonLiteral(path.resolve('.swcrc'))
-  return json`
-{
-  "jsc": {
-    "parser": {
-      "syntax": "typescript",
-      "decorators": false,
-      "dynamicImport": true
-    },
-    "target": "es2022",
-    "externalHelpers": false
-  },
-  "module": {
-    "type": "es6",
-    "noInterop": false
-  },
-  "sourceMaps": true,  
-  "exclude": ["../../node_modules"]
-}
-  `
-}

package/src/lib/templates/tsconfig.template.ts

@@ -1,37 +0,0 @@
-import {jsonLiteral} from "@intrig/plugin-sdk";
-import * as path from "path";
-
-export function reactTsConfigTemplate() {
-  const json = jsonLiteral(path.resolve('tsconfig.json'))
-  return json`
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "ESNext",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "noImplicitAny": false,
-    "moduleResolution": "node",
-    "baseUrl": "./",
-    "paths": {
-      "@intrig/react": [
-        "./src"
-      ],
-      "@intrig/react/*": [
-        "./src/*"
-      ],
-      "intrig-hook": ["src/config/intrig"]
-    },
-    "jsx": "react-jsx",
-    "skipLibCheck": true
-  },
-  "exclude": [
-    "node_modules",
-    "../../node_modules",
-    "**/__tests__/*"
-  ]
-}
-  `
-}

package/src/lib/templates/type-utils.template.ts

@@ -1,28 +0,0 @@
-import {typescript} from "@intrig/plugin-sdk";
-import path from "path";
-
-export function typeUtilsTemplate() {
-  const ts = typescript(path.resolve('src', 'type-utils.ts'))
-
-  return ts`import { z } from 'zod';
-
-export type BinaryData = Blob;
-export const BinaryDataSchema: z.ZodType<BinaryData> = z.instanceof(Blob);
-
-// Base64 helpers (browser + Node compatible; no Buffer required)
-export function base64ToUint8Array(b64: string): Uint8Array {
-  if (typeof atob === 'function') {
-    // Browser
-    const bin = atob(b64);
-    const bytes = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
-    return bytes;
-  } else {
-    // Node
-    const buf = Buffer.from(b64, 'base64');
-    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-  }
-}
-
-  `
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "../../lib/plugin-sdk"
-    },
-    {
-      "path": "./tsconfig.lib.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,20 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "baseUrl": ".",
-    "rootDir": "src",
-    "outDir": "dist",
-    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
-    "emitDeclarationOnly": true,
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*.ts"],
-  "references": [
-    {
-      "path": "../../lib/plugin-sdk/tsconfig.lib.json"
-    }
-  ]
-}