A
arktype•2mo ago
Schmime

Is there a better way to write this?

import { type } from "arktype"; export const nonEmptyStringOrNull = type("string | null | undefined").pipe(s => !s ? null : s);
84 Replies
Schmime
SchmimeOP•2mo ago
And for using it is there a better alternative than this everywhere? 
type({ email: nonEmptyStringOrNull.to("string.email | null"), })
type({ email: nonEmptyStringOrNull.to("string.email | null"), })
ssalbdivad
ssalbdivad•2mo ago
This looks good in terms of the implementation. There is an issue tracked here that could add a config option for how values like empty string are treated in terms of defaultability: https://github.com/arktypeio/arktype/issues/1283
GitHub
Allow null to be treated as not-present for optional fields · Issue...
Request a feature (Related to #1191) I wish to be able to have a type with an optional non-null field that accepts null as being equivalent to not present: import { scope } from "arktype"...
ssalbdivad
ssalbdivad•2mo ago
You can use a generic if you want to apply that union + transformation to an arbitrary string input like string.email in a reusable way: https://arktype.io/docs/generics
ArkType Docs
Optimized runtime validation for TypeScript syntax
Schmime
SchmimeOP•2mo ago
@ssalbdivad thank you David! I decided to use Arktype for my work project so my fate is tied to it lol. Two questions, how can I make a key in my type optional but if you don't include it it falls back to the value null? Can I do that in a generic way? When you take a look at OpenAPI stuff can you please make sure it works with Hono OpenAPI? Thanks! https://github.com/rhinobase/hono-openapi
GitHub
GitHub - rhinobase/hono-openapi: A plugin for Hono to generate Open...
A plugin for Hono to generate OpenAPI Swagger documentation - rhinobase/hono-openapi
ssalbdivad
ssalbdivad•2mo ago
Sounds like a normal defaultable property https://arktype.io/docs/objects#properties-defaultable
ArkType Docs
Optimized runtime validation for TypeScript syntax
Schmime
SchmimeOP•2mo ago
I couldn't figure out the syntax, could you show by making this defaultable to null? Pretending I had done "email?"
ssalbdivad
ssalbdivad•2mo ago
type({ email: nonEmptyStringOrNull.to("string.email | null").default(null) })
type({ email: nonEmptyStringOrNull.to("string.email | null").default(null) })
Schmime
SchmimeOP•2mo ago
Hmmmmm LOL Ill try it when I'm next at my computer but I could have sworn default was not a property on to()
ssalbdivad
ssalbdivad•2mo ago
I mean I guess the whole .to() thing doesn't really makes sense TBH I just copied that haha but .default should be on every type Or I'll rephrase that- it does make sense it just not the cleanest way to do it, and is especially confusing because nonEmptyStringOrNull sounds like a validator but actually also transforms With a generic you should just be able to validate string.email in place of where string was in the original type
Schmime
SchmimeOP•2mo ago
I'm brand new to Arktype, could I see how you would make that type? Also is there a playground link you use to play around with Arktype?
ssalbdivad
ssalbdivad•2mo ago
No playground for 2.0 yet unfortunately. Here's one way to do it: 
const stringParserOrOptional = type("<s extends string>", [
    "s | null | undefined",
    "=>",
    s => (!s ? null : s)
])

const parseEmailOrNull = stringParserOrOptional("string.email")

const user = type({
    email: parseEmailOrNull.default(null)
})
const stringParserOrOptional = type("<s extends string>", [
    "s | null | undefined",
    "=>",
    s => (!s ? null : s)
])

const parseEmailOrNull = stringParserOrOptional("string.email")

const user = type({
    email: parseEmailOrNull.default(null)
})
Schmime
SchmimeOP•2mo ago
I'm not at my computer right now, does the default imply the type of email would now be "email?" ? Thank you for the help!
ssalbdivad
ssalbdivad•2mo ago
Not sure exactly what you mean but since TS does not have an email type it would still be inferred as string, it would just be enforced as email
Schmime
SchmimeOP•2mo ago
I mean if I pass in an empty object would that type assert successfully and give me back an object with an email field of null I tried to try it on codesandbox but it's hell to use that site on a mobile device lol
ssalbdivad
ssalbdivad•2mo ago
Yeah
Schmime
SchmimeOP•2mo ago
Tried it out in Valtown and it worked! Have a great day!
ssalbdivad
ssalbdivad•2mo ago
Sweet! Hope the adoption continues to go well 😊
Schmime
SchmimeOP•2mo ago
My only real complaint right now is wow LLMs are terrible at Arktype, but I think I saw there was a GitHub issue for that
ssalbdivad
ssalbdivad•2mo ago
Yeah will be sure to add llms.txt which hopefully will help. Plus as newer model released obviously will just improve with more training data The more it has context on your own valid definitions though the better it should do
Schmime
SchmimeOP•2mo ago
Im so sorry for more questions I am struggling to figure out the syntax for combining multiple keyword validations into a generic 
const nonEmptyStringParser = type("<s extends string>", [
  "string.trim",
  "string > 0",
]);
const nonEmptyStringParser = type("<s extends string>", [
  "string.trim",
  "string > 0",
]);
ssalbdivad
ssalbdivad•2mo ago
Compare to something like: 
type nonEmptyString<s extends string> = s extends "" ? false : true
type nonEmptyString<s extends string> = s extends "" ? false : true
What you want there is body of the generic. it should reference s (whatever string you pass in) and then apply more constraints to it. In my original case, I applied a morph to it with the morph tuple expression =>
Schmime
SchmimeOP•2mo ago
How would I add a string.trim to this?
ssalbdivad
ssalbdivad•2mo ago
You could do something like this but at this point it may be easier to just create your own external generic function (there's an example of this in the generic section of the docs) that creates a type: 
const createTrimToNonEmpty = type("<s extends string>", [
    ["s", "|>", "string.trim"],
    "|>",
    "string > 0"
])

const trimToNonEmpty = createTrimToNonEmpty("string.email")
const createTrimToNonEmpty = type("<s extends string>", [
    ["s", "|>", "string.trim"],
    "|>",
    "string > 0"
])

const trimToNonEmpty = createTrimToNonEmpty("string.email")
Actually I guess you probably want the string constraint (e.g. email) to apply after it is trimmed, so you could do: 
const createTrimToNonEmpty = type("<s extends string>", [
    "string.trim",
    "|>",
    "s > 0"
])

const trimToNonEmpty = createTrimToNonEmpty("string.email")
const createTrimToNonEmpty = type("<s extends string>", [
    "string.trim",
    "|>",
    "s > 0"
])

const trimToNonEmpty = createTrimToNonEmpty("string.email")
A lot of string subtypes would already be guaranteed non-empty anyways though
Schmime
SchmimeOP•3w ago
When I pass in a string literal to stringParserOrOptional it its typed as string instead of the literals https://discord.com/channels/957797212103016458/1350886854844612678/1350886854844612678
ssalbdivad
ssalbdivad•3w ago
This looks like a limitation of how TS handles generic inference in a case like this. Probably best to just write the generic manually like this: 
import type { ErrorMessage, trim } from "@ark/util"
import { type } from "arktype"
import type { inferPipe } from "arktype/internal/attributes.ts"

const trim = type.keywords.string.trim.root

const createTrimToNonEmpty = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"Must be a string">
    :    type.validate<def>
): type<inferPipe<typeof trim.t, type.infer<def>>> => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)
    return trim.to(nonEmpty) as never
}

const trimToNonEmptyEmail = createTrimToNonEmpty("string.email")
import type { ErrorMessage, trim } from "@ark/util"
import { type } from "arktype"
import type { inferPipe } from "arktype/internal/attributes.ts"

const trim = type.keywords.string.trim.root

const createTrimToNonEmpty = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"Must be a string">
    :    type.validate<def>
): type<inferPipe<typeof trim.t, type.infer<def>>> => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)
    return trim.to(nonEmpty) as never
}

const trimToNonEmptyEmail = createTrimToNonEmpty("string.email")
Schmime
SchmimeOP•3w ago
😬 THANK YOU BUT WOW I WOULD NEVER HAVE GOTTEN THAT LOL Oh wait sorry, I meant I was having trouble with this function 
const nonEmptyStringOrNull = type("<s extends string>", [
  "s | null | undefined",
  "=>",
  (s) => (!s ? null : s),
]);
const nonEmptyStringOrNull = type("<s extends string>", [
  "s | null | undefined",
  "=>",
  (s) => (!s ? null : s),
]);
ssalbdivad
ssalbdivad•3w ago
Writing TS generics and especially integrating them with library types gets hard fast haha. That's why we try to get as many APIs to work out of the box as possible without wrapping. This kind of pattern can be reused for other cases though Maybe a good exercise then to see if you can adapt what I wrote for that case 😛
Schmime
SchmimeOP•3w ago
Im using Valtown as a playground, do you have a prefered alternative?
ssalbdivad
ssalbdivad•3w ago
You can try https://arktype.io/playground to check the types
ArkType Docs
TypeScript's 1:1 validator, optimized from editor to runtime
ssalbdivad
ssalbdivad•3w ago
It's not finalized/announced yet but the types seem to be working
Schmime
SchmimeOP•3w ago
Really sorry to bother you but I think syntax might be wrong, in the playground its not showing a type if you hover over timeToNotEmptyEmail, and on valtown its interpreting it as JSX https://www.val.town/v/arjunyel/arkTypeTest
Val Town
@arjunyel/arkTypeTest
An interactive, runnable TypeScript val by arjunyel
ssalbdivad
ssalbdivad•3w ago
Haha seems like a JSX parsing bug... the syntax is definitely right I wrote it in my own editor!
Schmime
SchmimeOP•3w ago
As soon as arktype llm.txt I promise I wont be bothering you 😄
ssalbdivad
ssalbdivad•3w ago
There are some cases like this where I've seen .jsx files fail to parse because they get confused about generics You can probably fix it by changing const def to const def extends unknown Haha unfortunately issues like these that have more to do with ts generics in general I don't think it will help much with
Schmime
SchmimeOP•3w ago
const def extends unknown works if you run it but typescript still cant read it https://www.val.town/v/arjunyel/arkTypeTest
Val Town
@arjunyel/arkTypeTest
An interactive, runnable TypeScript val by arjunyel
ssalbdivad
ssalbdivad•3w ago
Maybe ping val.town about their parser? Definitely works in pure ts
No description
Schmime
SchmimeOP•3w ago
Im trying to get closer but its saying 'trim' only refers to a type, but is being used as a value here. 
import { type ErrorMessage, trim } from "@ark/util";
import type { inferPipe } from "arktype/internal/attributes.ts";
import { type } from "arktype";

export const nonEmptyStringOrNull = <const def>(
  def: def extends type.validate<def>
    ? type.infer<def> extends string
      ? def
      : type.infer<def> extends null
        ? def
        : ErrorMessage<"Must be a string">
    : type.validate<def>,
): type<
  inferPipe<
    typeof type.keywords.string.root.t | typeof type.keywords.null,
    type.infer<def>
  >
> => {
  if (
    type.raw(def).equals(type.keywords.null) ||
    type.raw(def).equals(type.keywords.undefined)
  ) {
    return type.keywords.null as never;
  }
  const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
  return trim.to(nonEmpty) as never;
};
import { type ErrorMessage, trim } from "@ark/util";
import type { inferPipe } from "arktype/internal/attributes.ts";
import { type } from "arktype";

export const nonEmptyStringOrNull = <const def>(
  def: def extends type.validate<def>
    ? type.infer<def> extends string
      ? def
      : type.infer<def> extends null
        ? def
        : ErrorMessage<"Must be a string">
    : type.validate<def>,
): type<
  inferPipe<
    typeof type.keywords.string.root.t | typeof type.keywords.null,
    type.infer<def>
  >
> => {
  if (
    type.raw(def).equals(type.keywords.null) ||
    type.raw(def).equals(type.keywords.undefined)
  ) {
    return type.keywords.null as never;
  }
  const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
  return trim.to(nonEmpty) as never;
};
ssalbdivad
ssalbdivad•3w ago
Trim should be this: const trim = type.keywords.string.trim.root
Schmime
SchmimeOP•3w ago
Thank you so much I think Im almost there!!!!! const test: string | (Type<null, Ark> & string) but im expecting string | null 
import { type ErrorMessage, trim } from "@ark/util";
import type { inferPipe } from 
"arktype/internal/attributes.ts";
import {type } from "arktype";

const trim = type.keywords.string.trim.root;

export const nonEmptyStringOrNull = <const def>(
  def: def extends type.validate<def>
    ? type.infer<def> extends string
      ? def
      : type.infer<def> extends null
        ? def
        : type.infer<def> extends undefined
          ? def
          : ErrorMessage<"Must be a string">
    : type.validate<def>,
): type<
  inferPipe<
    typeof type.keywords.string.root.t | typeof type.keywords.null,
    type.infer<def>
  >
> => {
  if (
    type.raw(def).equals(type.keywords.null) ||
    type.raw(def).equals(type.keywords.undefined)
  ) {
    return type.keywords.null as never;
  }
  const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
  const trimmed = trim.to(nonEmpty);
  return trimmed.pipe((s) => (!s ? null : s)) as never;
};

const trimToNonEmptyEmail = nonEmptyStringOrNull("string.email");
const test = trimToNonEmptyEmail.from("safe");
import { type ErrorMessage, trim } from "@ark/util";
import type { inferPipe } from 
"arktype/internal/attributes.ts";
import {type } from "arktype";

const trim = type.keywords.string.trim.root;

export const nonEmptyStringOrNull = <const def>(
  def: def extends type.validate<def>
    ? type.infer<def> extends string
      ? def
      : type.infer<def> extends null
        ? def
        : type.infer<def> extends undefined
          ? def
          : ErrorMessage<"Must be a string">
    : type.validate<def>,
): type<
  inferPipe<
    typeof type.keywords.string.root.t | typeof type.keywords.null,
    type.infer<def>
  >
> => {
  if (
    type.raw(def).equals(type.keywords.null) ||
    type.raw(def).equals(type.keywords.undefined)
  ) {
    return type.keywords.null as never;
  }
  const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
  const trimmed = trim.to(nonEmpty);
  return trimmed.pipe((s) => (!s ? null : s)) as never;
};

const trimToNonEmptyEmail = nonEmptyStringOrNull("string.email");
const test = trimToNonEmptyEmail.from("safe");
ssalbdivad
ssalbdivad•3w ago
I would just change the return to 
inferPipe<
   string | null | undefined,
    type.infer<def> | null
  >
inferPipe<
   string | null | undefined,
    type.infer<def> | null
  >
Assuming you always want to accept a string initially, you can also remove a lot of the null | undefined logic and just add that to the piped union at the beginning e.g. : 
const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
const trimmed = trim.to(nonEmpty);
const nullOrUndefinedToNull = type("null | undefined").pipe(v => null)
return trimmed.or(nullOrUndefinedToNull)
const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
const trimmed = trim.to(nonEmpty);
const nullOrUndefinedToNull = type("null | undefined").pipe(v => null)
return trimmed.or(nullOrUndefinedToNull)
Schmime
SchmimeOP•3w ago
Im still super struggling Can I pay you for help or something? 
const trim = type.keywords.string.trim.root;

export const nonEmptyStringOrNull = <const def>(
  def: def extends type.validate<def>
    ? type.infer<def> extends string
      ? def
      : type.infer<def> extends null
        ? def
        : type.infer<def> extends undefined
          ? def
          : ErrorMessage<"Must be a string">
    : type.validate<def>,
): type<inferPipe<string | null | undefined, type.infer<def> | null>> => {
  if (
    type.raw(def).equals(type.keywords.null) ||
    type.raw(def).equals(type.keywords.undefined)
  ) {
    return type.keywords.null as never;
  }
  const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
  const trimmed = trim.to(nonEmpty);
  return trimmed.pipe((s) => (!s ? null : s)) as never;
};

const test = type({ email: nonEmptyStringOrNull("string") });

console.log(test.from({}));
const trim = type.keywords.string.trim.root;

export const nonEmptyStringOrNull = <const def>(
  def: def extends type.validate<def>
    ? type.infer<def> extends string
      ? def
      : type.infer<def> extends null
        ? def
        : type.infer<def> extends undefined
          ? def
          : ErrorMessage<"Must be a string">
    : type.validate<def>,
): type<inferPipe<string | null | undefined, type.infer<def> | null>> => {
  if (
    type.raw(def).equals(type.keywords.null) ||
    type.raw(def).equals(type.keywords.undefined)
  ) {
    return type.keywords.null as never;
  }
  const nonEmpty = type.raw(def).as<string>().atLeastLength(1);
  const trimmed = trim.to(nonEmpty);
  return trimmed.pipe((s) => (!s ? null : s)) as never;
};

const test = type({ email: nonEmptyStringOrNull("string") });

console.log(test.from({}));
This should output { email: null } This works perfect, just doesnt keep string literals in the output type 
export const nonEmptyStringOrNull1 = type("<s extends string>", [
  "s | null | undefined",
  "=>",
  // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
  (s) => (!s ? null : s),
]);
export const nonEmptyStringOrNull1 = type("<s extends string>", [
  "s | null | undefined",
  "=>",
  // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
  (s) => (!s ? null : s),
]);
TizzySaurus
TizzySaurus•3w ago
What exactly are you trying to achieve here? A value which is a string, or if not specified defaults to null?
Schmime
SchmimeOP•3w ago
This but it also works with string literals 
const nonEmptyStringOrNull = type("<s extends string>", [
  "s | null | undefined",
  "=>",
  (s) => (!s ? null : s),
]);
const nonEmptyStringOrNull = type("<s extends string>", [
  "s | null | undefined",
  "=>",
  (s) => (!s ? null : s),
]);
Last 3 lines of this is a test case
TizzySaurus
TizzySaurus•3w ago
Where does type.keywords.string.trim.root come into it?
Schmime
SchmimeOP•3w ago
That was extra but basically it would be nice if the string was trimmed before we check it it's empty
TizzySaurus
TizzySaurus•3w ago
Right Well this doesn't do "test.from({}) should output { email: null }" This still requires whatever key to have an explicit value
Schmime
SchmimeOP•3w ago
It works when I ran it, did it not work for you?
TizzySaurus
TizzySaurus•3w ago
So do you want the key to be required, or should it default to null?
Schmime
SchmimeOP•3w ago
Key is not required, if it's missing it's set to value null
TizzySaurus
TizzySaurus•3w ago
const nonEmptyStringOrNull = type("<s extends string>", [
    "s | null | undefined",
    "=>",
    s => (!s ? null : s)
])

const test = type({ email: nonEmptyStringOrNull("string") })

console.log(test.from({})) // errors saying 'email' must be present
const nonEmptyStringOrNull = type("<s extends string>", [
    "s | null | undefined",
    "=>",
    s => (!s ? null : s)
])

const test = type({ email: nonEmptyStringOrNull("string") })

console.log(test.from({})) // errors saying 'email' must be present
this errors (both types and runtime) So "if input's value is an empty string, or null/undefined, or not provided, the output's value should be null. Otherwise use the provided value as the output"?
Schmime
SchmimeOP•3w ago
Hmmmmm I swear it was working.... Not sure what happened.. maybe I'm imagining things. Basically I pay you if I can get some function that supports strings and literals, if the key is missing or empty or empty after trimming I want the value set to null Correct, it would be nice if it handled the Arktype string types like email
TizzySaurus
TizzySaurus•3w ago
I mean this sounds simple enough.... Give me a minute... And I'm assuming you also need the generic inference so the type is s rather than string? Where s comes from the validator definition and not the usage
Schmime
SchmimeOP•3w ago
Sorry friend I am new to Arktype, the generic part was so I could pass in string or string subtypes like email or uuid
TizzySaurus
TizzySaurus•3w ago
Right, so in theory you just want email: nonEmptyStringOrNull, where nonEmptyStringOrNull does the validation I mentioned above (you don't strictly need the ("string") part of it)?
Schmime
SchmimeOP•3w ago
But how would I do nonemptystringornull("string.uuid") for example? I think that's why David recommended a generic
TizzySaurus
TizzySaurus•3w ago
Oh wait I see. You might want ("string.email") or ("string.uuid") Yeah Okay I think I understand If we do nonEmptyStringOrNull("string.email"), and the user provides "foo" (i.e. an invalid email), should the result be an error or null? @Schmime
Schmime
SchmimeOP•3w ago
Error
TizzySaurus
TizzySaurus•3w ago
Okay, I think I've got it 
const test = type({ email: nonEmptyStringOrNull("string.email") })

const r1 = test.from({})
// const r2 = test.from({ email: "hi" })
const r3 = test.from({ email: "  [email protected]   " })

console.log(r1) // {email: null}
// console.log(r2) // TraversalError: email must be an email address (was "hi")
console.log(r3) // {email: "[email protected]"}
const test = type({ email: nonEmptyStringOrNull("string.email") })

const r1 = test.from({})
// const r2 = test.from({ email: "hi" })
const r3 = test.from({ email: "  [email protected]   " })

console.log(r1) // {email: null}
// console.log(r2) // TraversalError: email must be an email address (was "hi")
console.log(r3) // {email: "[email protected]"}
does this seem good for test cases? @Schmime
Schmime
SchmimeOP•3w ago
That looks amazing
TizzySaurus
TizzySaurus•3w ago
I'm just figuring out the correct things for the types then will send
Schmime
SchmimeOP•3w ago
👀👀👀👀
TizzySaurus
TizzySaurus•3w ago
There's also this when you do nonEmptyStringOrNull("number")
No description
TizzySaurus
TizzySaurus•3w ago
Hopefully this is good for you :)
import type { ErrorMessage } from "@ark/util"
import { type, type Out, type Type } from "arktype"

export const nonEmptyStringOrNull = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"specified validator must be a string validator">
    :    type.validate<def>
): [Type<(In: unknown) => Out<string | null>, {}>, "=", null] => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)

    return type.unknown
        .pipe(data => {
            if (type.keywords.string.trim.root.allows(data))
                return type.keywords.string.trim.root.to(nonEmpty)(data)

            return null
        })
        .default(null)
}

const test = type({ email: nonEmptyStringOrNull("string.email") })

const r1 = test.from({})
// const r2 = test.from({ email: "hi" })
const r3 = test.from({ email: "  [email protected]   " })

console.log(r1) // {email: null}
// console.log(r2) // TraversalError: email must be an email address (was "hi")
console.log(r3) // {email: "[email protected]"}
import type { ErrorMessage } from "@ark/util"
import { type, type Out, type Type } from "arktype"

export const nonEmptyStringOrNull = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"specified validator must be a string validator">
    :    type.validate<def>
): [Type<(In: unknown) => Out<string | null>, {}>, "=", null] => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)

    return type.unknown
        .pipe(data => {
            if (type.keywords.string.trim.root.allows(data))
                return type.keywords.string.trim.root.to(nonEmpty)(data)

            return null
        })
        .default(null)
}

const test = type({ email: nonEmptyStringOrNull("string.email") })

const r1 = test.from({})
// const r2 = test.from({ email: "hi" })
const r3 = test.from({ email: "  [email protected]   " })

console.log(r1) // {email: null}
// console.log(r2) // TraversalError: email must be an email address (was "hi")
console.log(r3) // {email: "[email protected]"}
Oof, discord syntax highlighting doesn't like that lmao Looks like the type.raw is needed actually (have edited it back in) 🙈
Schmime
SchmimeOP•3w ago
Module '"arktype"' has no exported member 'Out'.
TizzySaurus
TizzySaurus•3w ago
Ah, I guess my PR adds that export 😅 https://github.com/arktypeio/arktype/pull/1159
GitHub
feat: support JSON Schema as input for a Type by TizzySaurus · Pul...
Closes #729. What This PR adds @ark/jsonschema, which is a library enabling users to convert a valid JSON Schema schema into an ArkType type. API Below is a basic sample-use of @ark/jsonschema: imp...
TizzySaurus
TizzySaurus•3w ago
Let me find the code for it... 
export interface Out<o = any> { // NB: This will be a public export as of ArkType v2.2
    [" isMorphOut"]: true // TypeScript won't suggest strings beginning with a space as properties. Useful for symbol-like string properties such as this.
    t: o
    introspectable: boolean
}
export interface Out<o = any> { // NB: This will be a public export as of ArkType v2.2
    [" isMorphOut"]: true // TypeScript won't suggest strings beginning with a space as properties. Useful for symbol-like string properties such as this.
    t: o
    introspectable: boolean
}
@Schmime Add this to your file instead of the type Out import. It hopefully won't be necessary in ArkType 2.2+ (the next release), but it is for now
Schmime
SchmimeOP•3w ago
THANK YOU SO MUCH!!!! I think we are super close, last test case should be r2 should return { email: null }, right now its throwing an error const test = type({ email: nonEmptyStringOrNull("string") }); const r1 = test.from({}); const r2 = test.from({ email: "" }); const r3 = test.from({ email: " [email protected] " }); console.log(r1); // {email: null} console.log(r2); // TraversalError: email must be an email address (was "hi") console.log(r3); // {email: "[email protected]"}
TizzySaurus
TizzySaurus•3w ago
You said here r2 should error 😅 I guess because it was non-empty Okay... that's easy enough... one sec
Schmime
SchmimeOP•3w ago
Sorry I changed "string.email" to just "string" as a test
TizzySaurus
TizzySaurus•3w ago
Hmmm So should "" be null, and "a" be an error for string.email?
Schmime
SchmimeOP•3w ago
Yes exactly Example usecase is in a frontned form if a feild is empty itll send an empty string, but id want to store as null in database
TizzySaurus
TizzySaurus•3w ago
Okay... I mean honestly the easiest thing is just explicitly check for ""
Schmime
SchmimeOP•3w ago
Check has to be after trim
TizzySaurus
TizzySaurus•3w ago
        ...
     return type.unknown
        .pipe(data => {
                        if (data === "") return null
            if (type.keywords.string.trim.root.allows(data))
                return type.keywords.string.trim.root.to(nonEmpty)(data)

            return null
        })
        .default(null)
        ...
     return type.unknown
        .pipe(data => {
                        if (data === "") return null
            if (type.keywords.string.trim.root.allows(data))
                return type.keywords.string.trim.root.to(nonEmpty)(data)

            return null
        })
        .default(null)
Schmime
SchmimeOP•3w ago
So this is soooo close, just I need to do the === "" check after the trim is applied
TizzySaurus
TizzySaurus•3w ago
Yeah, it's easy enough to do I'm just seeing the best way
Schmime
SchmimeOP•3w ago
I have to leave my computer to go, I appreciate your help so much, can you DM me the best way to pay you?
TizzySaurus
TizzySaurus•3w ago
export const nonEmptyStringOrNull = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"specified validator must be a string validator">
    :    type.validate<def>
): [Type<(In: unknown) => Out<string | null>, {}>, "=", null] => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)

    return type.unknown
        .pipe(data => {
            const trimResult = type.keywords.string.trim.root(data)
            if (trimResult instanceof type.errors) return null
            else return trimResult === "" ? null : nonEmpty(trimResult)
        })
        .default(null)
}
export const nonEmptyStringOrNull = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"specified validator must be a string validator">
    :    type.validate<def>
): [Type<(In: unknown) => Out<string | null>, {}>, "=", null] => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)

    return type.unknown
        .pipe(data => {
            const trimResult = type.keywords.string.trim.root(data)
            if (trimResult instanceof type.errors) return null
            else return trimResult === "" ? null : nonEmpty(trimResult)
        })
        .default(null)
}
I think this is what you want Hmm I guess maybe not... let me think
Schmime
SchmimeOP•3w ago
Ill test whatever you come up when I get home. Btw I insist on paying you lol
TizzySaurus
TizzySaurus•3w ago
This should be good :)
export const nonEmptyStringOrNull = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"specified validator must be a string validator">
    :    type.validate<def>
): [Type<(In: unknown) => Out<string | null>, {}>, "=", null] => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)

    return type.unknown
        .pipe(data => {
            if (data === undefined || data === null) return null

            const trimResult = type.keywords.string.trim.root.assert(data)
            return trimResult === "" ? null : nonEmpty(trimResult)
        })
        .default(null)
}

const test = type({ email: nonEmptyStringOrNull("string.email") })
export const nonEmptyStringOrNull = <const def>(
    def: def extends type.validate<def> ?
        type.infer<def> extends string ?
            def
        :    ErrorMessage<"specified validator must be a string validator">
    :    type.validate<def>
): [Type<(In: unknown) => Out<string | null>, {}>, "=", null] => {
    const nonEmpty = type.raw(def).as<string>().atLeastLength(1)

    return type.unknown
        .pipe(data => {
            if (data === undefined || data === null) return null

            const trimResult = type.keywords.string.trim.root.assert(data)
            return trimResult === "" ? null : nonEmpty(trimResult)
        })
        .default(null)
}

const test = type({ email: nonEmptyStringOrNull("string.email") })
Schmime
SchmimeOP•3w ago
AHHHHHH I THINK ITS ALL WORKING YAY THANK YOU SO MUCH I SPENT SO MUCH TIME ON THIS LOL @ssalbdivad GIVE @TizzySaurus A RAISE PLEASE
TizzySaurus
TizzySaurus•3w ago
Lmaaooo All my work here is volunteer-based :) Honestly it's just great to help people out
Schmime
SchmimeOP•3w ago
Naw Im paying you, I insist
TizzySaurus
TizzySaurus•3w ago
Let's go DMs :)

Did you find this page helpful?