@flarehr/superhero-basic-profile 0.1.2214 → 0.1.2217

package/dist/Basic.Profile.Domain/ProfileCommandHandler.jsx

@@ -0,0 +1,261 @@
+import { Union } from "../fable_modules/fable-library-js.4.20.0/Types.js";
+import { union_type, list_type, string_type } from "../fable_modules/fable-library-js.4.20.0/Reflection.js";
+import { ProfileModule_getMetadata, ProfileModule_createPartial, ProfileModule_create, ProfileModule_tryActivate, PartialProfileDetailModule_update, ProfileModule_tryPromotePartial, ProfileModule_tryPurge, ProfileModule_Updater, ProfileDetail, ProfileModule_tryRestore, ProfileModule_tryArchive, ProfileModule_tryDeactivate, ProfileModule_tryUpdate, ProfileModule_incrementVersion, OperationalProfileModule_$007CFullDetails$007CPartialDetails$007CNonOperational$007C, Profile_$reflection } from "./DomainAggregates.jsx";
+import { Event$1, EventId, ProfileEvent, Event$1_$reflection, ProfileEvent_$reflection } from "./Events.jsx";
+import { length, append, fold, isEmpty, mapIndexed, empty, singleton } from "../fable_modules/fable-library-js.4.20.0/List.js";
+import { equals } from "../fable_modules/fable-library-js.4.20.0/Util.js";
+import { PartialProfileUpdateDetails } from "./ProfileModels.jsx";
+import { FSharpResult$2, Result_Map } from "../fable_modules/fable-library-js.4.20.0/Result.js";
+import { CommandMetadata_toEventMetadata, ProfileEventMetadataModule_incrementVersion, ProfileEventMetadataModule_toAggregateMetaData } from "./Metadata.jsx";
+import { newGuid } from "../fable_modules/fable-library-js.4.20.0/Guid.js";
+import { printf, toText } from "../fable_modules/fable-library-js.4.20.0/String.js";
+
+export class HandlerResult extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["NoChange", "InvalidCommand", "Conflict", "CreateProfile", "UpdateProfile"];
+    }
+}
+
+export function HandlerResult_$reflection() {
+    return union_type("ProfileCommandHandler.HandlerResult", [], HandlerResult, () => [[], [["Item", string_type]], [["Item", string_type]], [["Item1", Profile_$reflection()], ["Item2", list_type(Event$1_$reflection(ProfileEvent_$reflection()))]], [["Item1", Profile_$reflection()], ["Item2", list_type(Event$1_$reflection(ProfileEvent_$reflection()))]]]);
+}
+
+function ofCommand(profile, _arg) {
+    let partialDetail;
+    switch (_arg.tag) {
+        case 1:
+            return singleton(new ProfileEvent(1, [_arg.fields[0]]));
+        case 2: {
+            const update_1 = _arg.fields[0];
+            let matchResult, current;
+            if (profile == null) {
+                matchResult = 1;
+            }
+            else {
+                const activePatternResult = OperationalProfileModule_$007CFullDetails$007CPartialDetails$007CNonOperational$007C(profile);
+                switch (activePatternResult.tag) {
+                    case 0:
+                    case 2: {
+                        matchResult = 1;
+                        break;
+                    }
+                    default: {
+                        matchResult = 0;
+                        current = activePatternResult.fields[0];
+                    }
+                }
+            }
+            switch (matchResult) {
+                case 0:
+                    if (!equals(update_1, (partialDetail = current, new PartialProfileUpdateDetails(partialDetail.Name, partialDetail.Email, partialDetail.MobilePhone, partialDetail.Title, partialDetail.Gender, partialDetail.DateOfBirth, partialDetail.Address)))) {
+                        return singleton(new ProfileEvent(2, [update_1]));
+                    }
+                    else {
+                        return empty();
+                    }
+                default:
+                    return empty();
+            }
+        }
+        case 3:
+            return singleton(new ProfileEvent(3, [_arg.fields[0]]));
+        case 4:
+            return singleton(new ProfileEvent(4, []));
+        case 5:
+            return singleton(new ProfileEvent(5, []));
+        case 6:
+            return singleton(new ProfileEvent(6, []));
+        case 7:
+            return singleton(new ProfileEvent(7, []));
+        case 8:
+            return singleton(new ProfileEvent(8, [_arg.fields[0]]));
+        case 9:
+            return singleton(new ProfileEvent(9, [_arg.fields[0]]));
+        case 10:
+            return singleton(new ProfileEvent(10, [_arg.fields[0]]));
+        case 11:
+            return singleton(new ProfileEvent(11, [_arg.fields[0]]));
+        case 12:
+            return singleton(new ProfileEvent(12, [_arg.fields[0]]));
+        case 13:
+            return singleton(new ProfileEvent(13, [_arg.fields[0]]));
+        case 14:
+            return singleton(new ProfileEvent(14, [_arg.fields[0]]));
+        case 15:
+            return singleton(new ProfileEvent(15, [_arg.fields[0]]));
+        case 16:
+            return singleton(new ProfileEvent(16, []));
+        default:
+            return singleton(new ProfileEvent(0, [_arg.fields[0]]));
+    }
+}
+
+function markUpdated(timestamp, profile) {
+    return ProfileModule_incrementVersion(0, timestamp, profile);
+}
+
+function update(timestamp, profile, updater) {
+    return Result_Map((profile_2) => markUpdated(timestamp, profile_2), ProfileModule_tryUpdate(updater, profile));
+}
+
+function applyToExisting(profile, event) {
+    const ts = event.Metadata.Timestamp;
+    const markUpdated$0027 = (profile_1) => markUpdated(ts, profile_1);
+    const update$0027 = (profile_2, updater) => update(ts, profile_2, updater);
+    const matchValue = event.Data;
+    switch (matchValue.tag) {
+        case 5:
+            return Result_Map(markUpdated$0027, ProfileModule_tryDeactivate(profile));
+        case 6:
+            return Result_Map(markUpdated$0027, ProfileModule_tryArchive(profile));
+        case 7:
+            return Result_Map(markUpdated$0027, ProfileModule_tryRestore(profile));
+        case 8:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p) => (new ProfileDetail(p.Metadata, p.AccountId, matchValue.fields[0], p.Title, p.Gender, p.Email, p.MobilePhone, p.DateOfBirth, p.Address, p.ExternalId, p.EmergencyContacts))]));
+        case 9:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p_1) => (new ProfileDetail(p_1.Metadata, p_1.AccountId, p_1.Name, matchValue.fields[0], p_1.Gender, p_1.Email, p_1.MobilePhone, p_1.DateOfBirth, p_1.Address, p_1.ExternalId, p_1.EmergencyContacts))]));
+        case 10:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p_2) => (new ProfileDetail(p_2.Metadata, p_2.AccountId, p_2.Name, p_2.Title, matchValue.fields[0], p_2.Email, p_2.MobilePhone, p_2.DateOfBirth, p_2.Address, p_2.ExternalId, p_2.EmergencyContacts))]));
+        case 11:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p_3) => (new ProfileDetail(p_3.Metadata, p_3.AccountId, p_3.Name, p_3.Title, p_3.Gender, matchValue.fields[0], p_3.MobilePhone, p_3.DateOfBirth, p_3.Address, p_3.ExternalId, p_3.EmergencyContacts))]));
+        case 12:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p_4) => (new ProfileDetail(p_4.Metadata, p_4.AccountId, p_4.Name, p_4.Title, p_4.Gender, p_4.Email, matchValue.fields[0], p_4.DateOfBirth, p_4.Address, p_4.ExternalId, p_4.EmergencyContacts))]));
+        case 13:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p_5) => (new ProfileDetail(p_5.Metadata, p_5.AccountId, p_5.Name, p_5.Title, p_5.Gender, p_5.Email, p_5.MobilePhone, matchValue.fields[0], p_5.Address, p_5.ExternalId, p_5.EmergencyContacts))]));
+        case 14:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p_6) => (new ProfileDetail(p_6.Metadata, p_6.AccountId, p_6.Name, p_6.Title, p_6.Gender, p_6.Email, p_6.MobilePhone, p_6.DateOfBirth, matchValue.fields[0], p_6.ExternalId, p_6.EmergencyContacts))]));
+        case 15:
+            return update$0027(profile, new ProfileModule_Updater(0, [(p_7) => (new ProfileDetail(p_7.Metadata, p_7.AccountId, p_7.Name, p_7.Title, p_7.Gender, p_7.Email, p_7.MobilePhone, p_7.DateOfBirth, p_7.Address, p_7.ExternalId, matchValue.fields[0]))]));
+        case 16:
+            return Result_Map(markUpdated$0027, ProfileModule_tryPurge(profile));
+        case 0:
+        case 1:
+            return new FSharpResult$2(1, ["Profile already exists"]);
+        case 3:
+            return Result_Map(markUpdated$0027, ProfileModule_tryPromotePartial(matchValue.fields[0], profile));
+        case 2:
+            return update$0027(profile, new ProfileModule_Updater(1, [(current) => PartialProfileDetailModule_update(matchValue.fields[0], current)]));
+        default:
+            return Result_Map(markUpdated$0027, ProfileModule_tryActivate(profile));
+    }
+}
+
+function applyToNewProfile(event) {
+    const aggregateMetadata = ProfileEventMetadataModule_toAggregateMetaData(event.Metadata);
+    const matchValue = event.Data;
+    switch (matchValue.tag) {
+        case 0:
+            return new FSharpResult$2(0, [ProfileModule_create(aggregateMetadata, matchValue.fields[0])]);
+        case 1:
+            return new FSharpResult$2(0, [ProfileModule_createPartial(aggregateMetadata, matchValue.fields[0])]);
+        default:
+            return new FSharpResult$2(1, ["Profile doesn\'t exist"]);
+    }
+}
+
+function eventFolder(state, event) {
+    if (state.tag === 0) {
+        if (state.fields[0] != null) {
+            return Result_Map((Value_1) => Value_1, applyToExisting(state.fields[0], event));
+        }
+        else {
+            return Result_Map((Value) => Value, applyToNewProfile(event));
+        }
+    }
+    else {
+        return new FSharpResult$2(1, [state.fields[0]]);
+    }
+}
+
+function triggerEvents(profile, command) {
+    return mapIndexed((index, event) => (new Event$1(new EventId(newGuid()), command.Id, event, ProfileEventMetadataModule_incrementVersion(index, CommandMetadata_toEventMetadata(command.Metadata)))), ofCommand(profile, command.Data));
+}
+
+function handleConsistentCommand(profile, command) {
+    const events = triggerEvents(profile, command);
+    if (isEmpty(events)) {
+        return new HandlerResult(0, []);
+    }
+    else {
+        const result = fold(eventFolder, new FSharpResult$2(0, [profile]), events);
+        const copyOfStruct = result;
+        if (copyOfStruct.tag === 1) {
+            return new HandlerResult(1, [copyOfStruct.fields[0]]);
+        }
+        else if (copyOfStruct.fields[0] != null) {
+            if (profile != null) {
+                const newProfile_1 = copyOfStruct.fields[0];
+                return new HandlerResult(4, [newProfile_1, events]);
+            }
+            else {
+                const newProfile = copyOfStruct.fields[0];
+                return new HandlerResult(3, [newProfile, events]);
+            }
+        }
+        else {
+            return new HandlerResult(0, []);
+        }
+    }
+}
+
+export function handle(profile, command) {
+    let arg_2;
+    const matchValue = command.Metadata.Version | 0;
+    if (profile != null) {
+        if (ProfileModule_getMetadata(profile).Version === matchValue) {
+            const p_1 = profile;
+            return handleConsistentCommand(profile, command);
+        }
+        else {
+            const p_2 = profile;
+            return new HandlerResult(2, [(arg_2 = (ProfileModule_getMetadata(p_2).Version | 0), toText(printf("Inconsistent command version: %i (should be %i)"))(matchValue)(arg_2))]);
+        }
+    }
+    else if (matchValue === 0) {
+        return handleConsistentCommand(profile, command);
+    }
+    else {
+        return new HandlerResult(2, [toText(printf("Inconsistent command version: %i (should be 0)"))(matchValue)]);
+    }
+}
+
+export function handleBatchUpdate(profile, commands) {
+    let p;
+    const result = fold((state, command) => {
+        if (state.tag === 0) {
+            const matchValue = handle(state.fields[0][1], command);
+            if (matchValue.tag === 4) {
+                return new FSharpResult$2(0, [[append(state.fields[0][0], matchValue.fields[1]), matchValue.fields[0]]]);
+            }
+            else {
+                return new FSharpResult$2(1, [toText(printf("%A"))(matchValue)]);
+            }
+        }
+        else {
+            return state;
+        }
+    }, new FSharpResult$2(0, [[empty(), profile]]), commands);
+    if (result.tag === 1) {
+        return new HandlerResult(2, [result.fields[0]]);
+    }
+    else {
+        const updatedProfileOption = result.fields[0][1];
+        const events_1 = result.fields[0][0];
+        if (updatedProfileOption == null) {
+            return new HandlerResult(2, ["Inconsistent batch of update commands"]);
+        }
+        else if ((p = updatedProfileOption, length(events_1) > 0)) {
+            const p_1 = updatedProfileOption;
+            return new HandlerResult(4, [p_1, events_1]);
+        }
+        else {
+            return new HandlerResult(0, []);
+        }
+    }
+}
+

package/dist/Basic.Profile.Domain/ProfileModels.jsx

@@ -0,0 +1,59 @@
+import { Record } from "../fable_modules/fable-library-js.4.20.0/Types.js";
+import { ExternalId_$reflection, Address_$reflection, DateOfBirth_$reflection, MobilePhone_$reflection, Email_$reflection, Gender_$reflection, Title_$reflection, Name_$reflection, AccountId_$reflection } from "./DomainPrimitives.jsx";
+import { record_type, option_type } from "../fable_modules/fable-library-js.4.20.0/Reflection.js";
+
+export class FullProfileCreationDetails extends Record {
+    constructor(AccountId, Name, Title, Gender, Email, MobilePhone, DateOfBirth, Address, ExternalId) {
+        super();
+        this.AccountId = AccountId;
+        this.Name = Name;
+        this.Title = Title;
+        this.Gender = Gender;
+        this.Email = Email;
+        this.MobilePhone = MobilePhone;
+        this.DateOfBirth = DateOfBirth;
+        this.Address = Address;
+        this.ExternalId = ExternalId;
+    }
+}
+
+export function FullProfileCreationDetails_$reflection() {
+    return record_type("ProfileModels.FullProfileCreationDetails", [], FullProfileCreationDetails, () => [["AccountId", AccountId_$reflection()], ["Name", Name_$reflection()], ["Title", Title_$reflection()], ["Gender", Gender_$reflection()], ["Email", Email_$reflection()], ["MobilePhone", MobilePhone_$reflection()], ["DateOfBirth", DateOfBirth_$reflection()], ["Address", Address_$reflection()], ["ExternalId", option_type(ExternalId_$reflection())]]);
+}
+
+export class PartialProfileCreationDetails extends Record {
+    constructor(AccountId, Name, Email, MobilePhone, ExternalId, Title, Gender, DateOfBirth, Address) {
+        super();
+        this.AccountId = AccountId;
+        this.Name = Name;
+        this.Email = Email;
+        this.MobilePhone = MobilePhone;
+        this.ExternalId = ExternalId;
+        this.Title = Title;
+        this.Gender = Gender;
+        this.DateOfBirth = DateOfBirth;
+        this.Address = Address;
+    }
+}
+
+export function PartialProfileCreationDetails_$reflection() {
+    return record_type("ProfileModels.PartialProfileCreationDetails", [], PartialProfileCreationDetails, () => [["AccountId", AccountId_$reflection()], ["Name", Name_$reflection()], ["Email", Email_$reflection()], ["MobilePhone", option_type(MobilePhone_$reflection())], ["ExternalId", option_type(ExternalId_$reflection())], ["Title", option_type(Title_$reflection())], ["Gender", option_type(Gender_$reflection())], ["DateOfBirth", option_type(DateOfBirth_$reflection())], ["Address", option_type(Address_$reflection())]]);
+}
+
+export class PartialProfileUpdateDetails extends Record {
+    constructor(Name, Email, MobilePhone, Title, Gender, DateOfBirth, Address) {
+        super();
+        this.Name = Name;
+        this.Email = Email;
+        this.MobilePhone = MobilePhone;
+        this.Title = Title;
+        this.Gender = Gender;
+        this.DateOfBirth = DateOfBirth;
+        this.Address = Address;
+    }
+}
+
+export function PartialProfileUpdateDetails_$reflection() {
+    return record_type("ProfileModels.PartialProfileUpdateDetails", [], PartialProfileUpdateDetails, () => [["Name", Name_$reflection()], ["Email", Email_$reflection()], ["MobilePhone", option_type(MobilePhone_$reflection())], ["Title", option_type(Title_$reflection())], ["Gender", option_type(Gender_$reflection())], ["DateOfBirth", option_type(DateOfBirth_$reflection())], ["Address", option_type(Address_$reflection())]]);
+}
+

package/dist/Basic.Profile.Domain/Utils.jsx

@@ -0,0 +1,372 @@
+import { create, match } from "../fable_modules/fable-library-js.4.20.0/RegExp.js";
+import { head, isEmpty, tail } from "../fable_modules/fable-library-js.4.20.0/List.js";
+import { map, delay, toList } from "../fable_modules/fable-library-js.4.20.0/Seq.js";
+import { interpolate, toText, isNullOrEmpty } from "../fable_modules/fable-library-js.4.20.0/String.js";
+import { FSharpResult$2 } from "../fable_modules/fable-library-js.4.20.0/Result.js";
+import { defaultOf } from "../fable_modules/fable-library-js.4.20.0/Util.js";
+import { tryParse } from "../fable_modules/fable-library-js.4.20.0/Int32.js";
+import { FSharpRef } from "../fable_modules/fable-library-js.4.20.0/Types.js";
+import { some } from "../fable_modules/fable-library-js.4.20.0/Option.js";
+import { create as create_1, isLeapYear } from "../fable_modules/fable-library-js.4.20.0/Date.js";
+
+export function $007CParseRegex$007C_$007C(regex, str) {
+    const m = match(create(regex), str);
+    if (m != null) {
+        return tail(toList(delay(() => map((x) => (x || ""), m))));
+    }
+    else {
+        return undefined;
+    }
+}
+
+export function $007CIsValidEmail$007C_$007C(input) {
+    let matchResult;
+    const activePatternResult = $007CParseRegex$007C_$007C(".*?@(.*)", input);
+    if (activePatternResult != null) {
+        if (!isEmpty(activePatternResult)) {
+            if (isEmpty(tail(activePatternResult))) {
+                matchResult = 0;
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return input;
+        default:
+            return undefined;
+    }
+}
+
+export function requireNonEmpty(name, value) {
+    if (isNullOrEmpty(value)) {
+        return new FSharpResult$2(1, [`${name} cannot be null or empty`]);
+    }
+    else {
+        return new FSharpResult$2(0, [value]);
+    }
+}
+
+export function requireMaxLength(maxLength, name, value) {
+    if (value === defaultOf()) {
+        return new FSharpResult$2(0, [value]);
+    }
+    else if (value.length <= maxLength) {
+        return new FSharpResult$2(0, [value]);
+    }
+    else {
+        return new FSharpResult$2(1, [toText(interpolate("%s%P() should not exceed %d%P() characters", [name, maxLength]))]);
+    }
+}
+
+export function requireEmail(value) {
+    const activePatternResult = $007CIsValidEmail$007C_$007C(value);
+    if (activePatternResult != null) {
+        const value_1 = activePatternResult;
+        return new FSharpResult$2(0, [value_1]);
+    }
+    else {
+        return new FSharpResult$2(1, ["Email is not in the correct format"]);
+    }
+}
+
+export function $007CInt$007C_$007C(str) {
+    let matchValue;
+    let outArg = 0;
+    matchValue = [tryParse(str, 511, false, 32, new FSharpRef(() => outArg, (v) => {
+        outArg = (v | 0);
+    })), outArg];
+    if (matchValue[0]) {
+        return matchValue[1];
+    }
+    else {
+        return undefined;
+    }
+}
+
+export function $007CBetween$007C_$007C(x, y, input) {
+    if ((input >= x) && (input <= y)) {
+        return some(undefined);
+    }
+    else {
+        return undefined;
+    }
+}
+
+export function Date_isLeapYear(year) {
+    return isLeapYear(year);
+}
+
+export function Date_getDateParts(dateErr, dateStr) {
+    const activePatternResult_3 = $007CParseRegex$007C_$007C("^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$", dateStr);
+    if (activePatternResult_3 != null) {
+        const d_1 = activePatternResult_3;
+        let matchResult, d_2, m_1, y_1;
+        if (!isEmpty(d_1)) {
+            if (!isEmpty(tail(d_1))) {
+                if (!isEmpty(tail(tail(d_1)))) {
+                    if (isEmpty(tail(tail(tail(d_1))))) {
+                        matchResult = 0;
+                        d_2 = head(tail(tail(d_1)));
+                        m_1 = head(tail(d_1));
+                        y_1 = head(d_1);
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0: {
+                const tupledArg = [y_1, m_1, d_2];
+                let matchResult_1, id, im, iy;
+                const activePatternResult = $007CInt$007C_$007C(tupledArg[0]);
+                if (activePatternResult != null) {
+                    const activePatternResult_1 = $007CInt$007C_$007C(tupledArg[1]);
+                    if (activePatternResult_1 != null) {
+                        const activePatternResult_2 = $007CInt$007C_$007C(tupledArg[2]);
+                        if (activePatternResult_2 != null) {
+                            matchResult_1 = 0;
+                            id = activePatternResult_2;
+                            im = activePatternResult_1;
+                            iy = activePatternResult;
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                }
+                else {
+                    matchResult_1 = 1;
+                }
+                switch (matchResult_1) {
+                    case 0:
+                        return new FSharpResult$2(0, [[iy, im, id]]);
+                    default:
+                        return new FSharpResult$2(1, [dateErr]);
+                }
+            }
+            default:
+                return new FSharpResult$2(1, [dateErr]);
+        }
+    }
+    else {
+        return new FSharpResult$2(1, [dateErr]);
+    }
+}
+
+function Date_tryParseHelper(dateErr, dateSuccess, dateOfBirth) {
+    const input_1 = Date_getDateParts(dateErr, dateOfBirth);
+    if (input_1.tag === 1) {
+        return new FSharpResult$2(1, [input_1.fields[0]]);
+    }
+    else {
+        const _arg = input_1.fields[0];
+        const year = _arg[0] | 0;
+        const month = _arg[1] | 0;
+        const day = _arg[2] | 0;
+        if (year <= 0) {
+            return new FSharpResult$2(1, [dateErr]);
+        }
+        else {
+            let matchResult;
+            if (month === 2) {
+                if ($007CBetween$007C_$007C(1, 29, day) != null) {
+                    if (Date_isLeapYear(year)) {
+                        matchResult = 0;
+                    }
+                    else {
+                        matchResult = 1;
+                    }
+                }
+                else {
+                    matchResult = 1;
+                }
+            }
+            else {
+                matchResult = 1;
+            }
+            switch (matchResult) {
+                case 0:
+                    return new FSharpResult$2(0, [dateSuccess(year, month, day)]);
+                default: {
+                    let matchResult_1;
+                    if (month === 2) {
+                        if ($007CBetween$007C_$007C(1, 28, day) != null) {
+                            if (!Date_isLeapYear(year)) {
+                                matchResult_1 = 0;
+                            }
+                            else {
+                                matchResult_1 = 1;
+                            }
+                        }
+                        else {
+                            matchResult_1 = 1;
+                        }
+                    }
+                    else {
+                        matchResult_1 = 1;
+                    }
+                    switch (matchResult_1) {
+                        case 0:
+                            return new FSharpResult$2(0, [dateSuccess(year, month, day)]);
+                        default: {
+                            let matchResult_2;
+                            switch (month) {
+                                case 1: {
+                                    if ($007CBetween$007C_$007C(1, 31, day) != null) {
+                                        matchResult_2 = 0;
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                    break;
+                                }
+                                case 3: {
+                                    if ($007CBetween$007C_$007C(1, 31, day) != null) {
+                                        matchResult_2 = 0;
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                    break;
+                                }
+                                case 5: {
+                                    if ($007CBetween$007C_$007C(1, 31, day) != null) {
+                                        matchResult_2 = 0;
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                    break;
+                                }
+                                case 7: {
+                                    if ($007CBetween$007C_$007C(1, 31, day) != null) {
+                                        matchResult_2 = 0;
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                    break;
+                                }
+                                case 8: {
+                                    if ($007CBetween$007C_$007C(1, 31, day) != null) {
+                                        matchResult_2 = 0;
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                    break;
+                                }
+                                case 10: {
+                                    if ($007CBetween$007C_$007C(1, 31, day) != null) {
+                                        matchResult_2 = 0;
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                    break;
+                                }
+                                case 12: {
+                                    if ($007CBetween$007C_$007C(1, 31, day) != null) {
+                                        matchResult_2 = 0;
+                                    }
+                                    else {
+                                        matchResult_2 = 1;
+                                    }
+                                    break;
+                                }
+                                default:
+                                    matchResult_2 = 1;
+                            }
+                            switch (matchResult_2) {
+                                case 0:
+                                    return new FSharpResult$2(0, [dateSuccess(year, month, day)]);
+                                default: {
+                                    let matchResult_3;
+                                    switch (month) {
+                                        case 4: {
+                                            if ($007CBetween$007C_$007C(1, 30, day) != null) {
+                                                matchResult_3 = 0;
+                                            }
+                                            else {
+                                                matchResult_3 = 1;
+                                            }
+                                            break;
+                                        }
+                                        case 6: {
+                                            if ($007CBetween$007C_$007C(1, 30, day) != null) {
+                                                matchResult_3 = 0;
+                                            }
+                                            else {
+                                                matchResult_3 = 1;
+                                            }
+                                            break;
+                                        }
+                                        case 9: {
+                                            if ($007CBetween$007C_$007C(1, 30, day) != null) {
+                                                matchResult_3 = 0;
+                                            }
+                                            else {
+                                                matchResult_3 = 1;
+                                            }
+                                            break;
+                                        }
+                                        case 11: {
+                                            if ($007CBetween$007C_$007C(1, 30, day) != null) {
+                                                matchResult_3 = 0;
+                                            }
+                                            else {
+                                                matchResult_3 = 1;
+                                            }
+                                            break;
+                                        }
+                                        default:
+                                            matchResult_3 = 1;
+                                    }
+                                    switch (matchResult_3) {
+                                        case 0:
+                                            return new FSharpResult$2(0, [dateSuccess(year, month, day)]);
+                                        default:
+                                            return new FSharpResult$2(1, [dateErr]);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+export function Date_isValid(dateErr, dateOfBirth) {
+    return Date_tryParseHelper(dateErr, (_arg, _arg_1, _arg_2) => {
+    }, dateOfBirth);
+}
+
+export function Date_tryParse(dateErr, dateOfBirth) {
+    return Date_tryParseHelper(dateErr, create_1, dateOfBirth);
+}
+