feat(exports): export zodOneFieldSchema

- simpler interface
- new field schema converter export
- updated name and imports/exports/tests to align with zodOneModelSchema

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod-to-dynamodb-onetable-schema",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Auto-generate `dynamodb-onetable` model schemas using `zod`, with best-in-class autocomplete",
   "keywords": [
     "dynamo",

src/converters/array.ts

@@ -1,4 +1,4 @@
-import { convertZodSchemaToField } from "../index";
+import { zodOneFieldSchema } from "../";
 import { Opts, Ref, ZodToOneField } from "../converter-type";
 import {
   ArrayCardinality,
@@ -53,7 +53,7 @@ export const convertArraySchema = <
       ZodArray<Schema, Cardinality>
     >;
   }
-  const items = convertZodSchemaToField(
+  const items = zodOneFieldSchema(
     innnerType,
     { currentPath: [...ref.currentPath, "0"] },
     opts,

src/converters/default.ts

@@ -1,4 +1,4 @@
-import { convertZodSchemaToField } from "../";
+import { zodOneFieldSchema } from "../";
 import { Opts, Ref, ZodToOneField } from "../converter-type";
 import { z, ZodDefault, ZodTypeAny } from "zod";
 
@@ -12,7 +12,7 @@ export const convertDefaultSchema = <T extends ZodTypeAny>(
   opts: Opts,
 ): ZodToOneField<ZodDefault<T>> => {
   const innerZodSchema = zodSchema._def.innerType;
-  const innerOneField = convertZodSchemaToField(innerZodSchema, ref, opts);
+  const innerOneField = zodOneFieldSchema(innerZodSchema, ref, opts);
   const defaultValue = zodSchema._def.defaultValue();
   return { ...innerOneField, default: defaultValue };
 };

src/converters/nullable.ts

@@ -1,4 +1,4 @@
-import { convertZodSchemaToField } from "../";
+import { zodOneFieldSchema } from "../";
 import { Opts, Ref, ZodToOneField } from "../converter-type";
 import { ZodNullable, ZodTypeAny } from "zod";
 
@@ -12,7 +12,7 @@ export const convertNullableSchema = <T extends ZodTypeAny>(
   ref: Ref,
   opts: Opts,
 ): ZodToOneField<ZodNullable<T>> => {
-  const innerField = convertZodSchemaToField(
+  const innerField = zodOneFieldSchema(
     zodSchema._def.innerType,
     ref,
     opts,

src/converters/object.ts

@@ -1,4 +1,4 @@
-import { convertZodSchemaToField } from "../";
+import { zodOneFieldSchema } from "../";
 import { Opts, Ref, ZodToOneField } from "../converter-type";
 import { ZodObject, ZodRawShape, ZodTypeAny } from "zod";
 
@@ -30,7 +30,7 @@ export const convertObjectSchema = <Schema extends ZodRawShape>(
   const schema = Object.entries(shape).reduce((acc, [propName, zodSchema]) => {
     return {
       ...acc,
-      [propName]: convertZodSchemaToField(
+      [propName]: zodOneFieldSchema(
         zodSchema as ZodTypeAny,
         { ...ref, currentPath: [...ref.currentPath, propName] },
         opts,

src/converters/optional.ts

@@ -1,4 +1,4 @@
-import { convertZodSchemaToField } from "../";
+import { zodOneFieldSchema } from "../";
 import { Opts, Ref, ZodToOneField } from "../converter-type";
 import { ZodOptional, ZodTypeAny } from "zod";
 
@@ -12,7 +12,7 @@ export const convertOptionalSchema = <T extends ZodTypeAny>(
   ref: Ref,
   opts: Opts,
 ): ZodToOneField<ZodOptional<T>> => {
-  const innerField = convertZodSchemaToField(
+  const innerField = zodOneFieldSchema(
     zodSchema._def.innerType,
     ref,
     opts,

src/index.ts

@@ -87,13 +87,13 @@ const getConverterFunction = <T extends ZodSchema>(
   }
 };
 
-export const convertZodSchemaToField = <T extends ZodSchema>(
+export const zodOneFieldSchema = <T extends ZodSchema>(
   zodSchema: T,
-  ref: Ref,
+  ref?: Ref,
   opts?: Opts,
 ): ZodToOneField<T> => {
   const converterFunction = getConverterFunction(zodSchema);
-  return converterFunction(zodSchema, ref, opts ?? {});
+  return converterFunction(zodSchema, ref ?? { currentPath: [] }, opts ?? {});
 };
 
 export const zodOneModelSchema = <T extends ZodRawShape>(
@@ -104,7 +104,7 @@ export const zodOneModelSchema = <T extends ZodRawShape>(
     (acc, [propName, zodSchema]) => {
       return {
         ...acc,
-        [propName]: convertZodSchemaToField(
+        [propName]: zodOneFieldSchema(
           zodSchema,
           { currentPath: [propName] },
           opts,

test/converters/array.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { z } from "zod";
-import { convertZodSchemaToField } from "../../src";
+import { zodOneFieldSchema } from "../../src";
 import { convertArraySchema } from "../../src/converters/array";
 import { Logger } from "winston";
 import { mock } from "vitest-mock-extended";
@@ -64,7 +64,7 @@ describe("convertArraySchema", () => {
       expect(onefield).toEqual({
         type: Array,
         required: true,
-        items: convertZodSchemaToField(schema, mockRefs, mockOpts),
+        items: zodOneFieldSchema(schema, mockRefs, mockOpts),
       });
     },
   );

test/converters/default.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
 import { z, ZodTypeAny } from "zod";
 import { convertDefaultSchema } from "../../src/converters/default";
-import { convertZodSchemaToField } from "../../src";
+import { zodOneFieldSchema } from "../../src";
 import { Logger } from "winston";
 import { mock } from "vitest-mock-extended";
 
@@ -36,7 +36,7 @@ describe("convertDefaultSchema", () => {
       // Assert
       expect(onefield).toEqual({
         default: defaultValue,
-        ...convertZodSchemaToField(schema, mockRefs, mockOpts),
+        ...zodOneFieldSchema(schema, mockRefs, mockOpts),
       });
     },
   );

test/index.test.ts

@@ -1,7 +1,3 @@
 import { it } from "vitest";
-import { convertZodSchemaToField } from "../src/index.ts";
-import { z } from "zod";
 
-it("should pass", () => {
-  convertZodSchemaToField(z.date(), { currentPath: [] }, {});
-});
+it("should pass", () => { });

test/convertZodSchemaToField.spec.ts → test/zodOneFieldSchema.spec.ts

@@ -2,13 +2,13 @@ import { describe, expect, it } from "vitest";
 import { z } from "zod";
 import { Logger } from "winston";
 import { mock } from "vitest-mock-extended";
-import { convertZodSchemaToField } from "../src";
+import { zodOneFieldSchema } from "../src";
 
 const mockLogger = mock<Logger>();
 const mockOpts = { logger: mockLogger };
 const mockRefs = { currentPath: ["hello"] };
 
-describe("convertZodSchemaToField", () => {
+describe("zodOneFieldSchema", () => {
   enum TestEnum {
     VALID = "VALID",
   }
@@ -31,7 +31,7 @@ describe("convertZodSchemaToField", () => {
     "should return a schema for valid $_def.typeName type",
     (schema) => {
       // Assemble
-      const onefield = convertZodSchemaToField(schema, mockRefs, mockOpts);
+      const onefield = zodOneFieldSchema(schema, mockRefs, mockOpts);
 
       // Act
       expect(onefield).toBeDefined();
@@ -70,8 +70,7 @@ describe("convertZodSchemaToField", () => {
     "should throw an error if invalid $_def.typeName types are used",
     (schema) => {
       // Act
-      const managedEffect = () =>
-        convertZodSchemaToField(schema, mockRefs, mockOpts);
+      const managedEffect = () => zodOneFieldSchema(schema, mockRefs, mockOpts);
 
       // Assert
       expect(managedEffect).toThrowError(