@palmares/schemas 0.0.1

package/dist/cjs/src/exceptions.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    NoAdapterFoundError: function() {
+        return NoAdapterFoundError;
+    },
+    SchemaAdapterNotImplementedError: function() {
+        return SchemaAdapterNotImplementedError;
+    },
+    TranslatableFieldNotImplementedError: function() {
+        return TranslatableFieldNotImplementedError;
+    }
+});
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var SchemaAdapterNotImplementedError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(SchemaAdapterNotImplementedError, Error1);
+    var _super = _create_super(SchemaAdapterNotImplementedError);
+    function SchemaAdapterNotImplementedError(args) {
+        _class_call_check(this, SchemaAdapterNotImplementedError);
+        return _super.call(this, "Schema adapter did not implement ".concat(args.functionName, " in ").concat(args.className));
+    }
+    return SchemaAdapterNotImplementedError;
+}(_wrap_native_super(Error));
+var NoAdapterFoundError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(NoAdapterFoundError, Error1);
+    var _super = _create_super(NoAdapterFoundError);
+    function NoAdapterFoundError() {
+        _class_call_check(this, NoAdapterFoundError);
+        return _super.call(this, 'No adapter found, please define an adapter using setDefaultAdapter() before using any schema.');
+    }
+    return NoAdapterFoundError;
+}(_wrap_native_super(Error));
+var TranslatableFieldNotImplementedError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(TranslatableFieldNotImplementedError, Error1);
+    var _super = _create_super(TranslatableFieldNotImplementedError);
+    function TranslatableFieldNotImplementedError(fieldName) {
+        _class_call_check(this, TranslatableFieldNotImplementedError);
+        return _super.call(this, "TranslatableField '".concat(fieldName, "' did not implement the 'schema' key on 'customAttributes'"));
+    }
+    return TranslatableFieldNotImplementedError;
+}(_wrap_native_super(Error));

package/dist/cjs/src/index.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ArrayFieldAdapter: function() {
+        return _array1.default;
+    },
+    ArraySchema: function() {
+        return _array.default;
+    },
+    BooleanFieldAdapter: function() {
+        return _boolean1.default;
+    },
+    BooleanSchema: function() {
+        return _boolean.default;
+    },
+    DatetimeFieldAdapter: function() {
+        return _datetime1.default;
+    },
+    DatetimeSchema: function() {
+        return _datetime.default;
+    },
+    FieldAdapter: function() {
+        return _fields.default;
+    },
+    NumberAdapter: function() {
+        return _number1.default;
+    },
+    NumberSchema: function() {
+        return _number.default;
+    },
+    ObjectFieldAdapter: function() {
+        return _object1.default;
+    },
+    ObjectSchema: function() {
+        return _object.default;
+    },
+    Schema: function() {
+        return _schema.default;
+    },
+    SchemaAdapter: function() {
+        return _adapter.default;
+    },
+    StringFieldAdapter: function() {
+        return _string1.default;
+    },
+    StringSchema: function() {
+        return _string.default;
+    },
+    UnionFieldAdapter: function() {
+        return _union1.default;
+    },
+    UnionSchema: function() {
+        return _union.default;
+    },
+    array: function() {
+        return _array.array;
+    },
+    boolean: function() {
+        return _boolean.boolean;
+    },
+    compile: function() {
+        return _compile.default;
+    },
+    datetime: function() {
+        return _datetime.datetime;
+    },
+    default: function() {
+        return _domain.default;
+    },
+    getSchemasWithDefaultAdapter: function() {
+        return getSchemasWithDefaultAdapter;
+    },
+    modelSchema: function() {
+        return _model.modelSchema;
+    },
+    number: function() {
+        return _number.number;
+    },
+    object: function() {
+        return _object.object;
+    },
+    schema: function() {
+        return _schema.schema;
+    },
+    setDefaultAdapter: function() {
+        return _conf.setDefaultAdapter;
+    },
+    string: function() {
+        return _string.string;
+    },
+    union: function() {
+        return _union.union;
+    }
+});
+var _adapter = /*#__PURE__*/ _interop_require_default(require("./adapter"));
+var _model = require("./model");
+var _array = /*#__PURE__*/ _interop_require_wildcard(require("./schema/array"));
+var _boolean = /*#__PURE__*/ _interop_require_wildcard(require("./schema/boolean"));
+var _datetime = /*#__PURE__*/ _interop_require_wildcard(require("./schema/datetime"));
+var _number = /*#__PURE__*/ _interop_require_wildcard(require("./schema/number"));
+var _object = /*#__PURE__*/ _interop_require_wildcard(require("./schema/object"));
+var _schema = /*#__PURE__*/ _interop_require_wildcard(require("./schema/schema"));
+var _string = /*#__PURE__*/ _interop_require_wildcard(require("./schema/string"));
+var _union = /*#__PURE__*/ _interop_require_wildcard(require("./schema/union"));
+var _domain = /*#__PURE__*/ _interop_require_default(require("./domain"));
+var _fields = /*#__PURE__*/ _interop_require_default(require("./adapter/fields"));
+var _number1 = /*#__PURE__*/ _interop_require_default(require("./adapter/fields/number"));
+var _object1 = /*#__PURE__*/ _interop_require_default(require("./adapter/fields/object"));
+var _union1 = /*#__PURE__*/ _interop_require_default(require("./adapter/fields/union"));
+var _string1 = /*#__PURE__*/ _interop_require_default(require("./adapter/fields/string"));
+var _array1 = /*#__PURE__*/ _interop_require_default(require("./adapter/fields/array"));
+var _boolean1 = /*#__PURE__*/ _interop_require_default(require("./adapter/fields/boolean"));
+var _datetime1 = /*#__PURE__*/ _interop_require_default(require("./adapter/fields/datetime"));
+var _conf = require("./conf");
+_export_star(require("./adapter/types"), exports);
+_export_star(require("./schema"), exports);
+var _compile = /*#__PURE__*/ _interop_require_default(require("./compile"));
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function getSchemasWithDefaultAdapter() {
+    return {
+        number: function() {
+            return _number.default.new();
+        },
+        string: function() {
+            return _string.default.new();
+        },
+        array: function() {
+            for(var _len = arguments.length, schemas = new Array(_len), _key = 0; _key < _len; _key++){
+                schemas[_key] = arguments[_key];
+            }
+            return _array.array.apply(void 0, _to_consumable_array(schemas));
+        },
+        boolean: function() {
+            return _boolean.default.new();
+        },
+        object: function(data) {
+            return _object.default.new(data);
+        },
+        union: function() {
+            for(var _len = arguments.length, schemas = new Array(_len), _key = 0; _key < _len; _key++){
+                schemas[_key] = arguments[_key];
+            }
+            return _union.default.new(schemas);
+        },
+        datetime: function() {
+            return _datetime.default.new();
+        },
+        /**
+     * Different from other models, this function is a factory function that returns either an ObjectSchema or an ArraySchema.
+     * The idea is to build the schema of a model dynamically based on its fields.
+     *
+     * Another feature is that it can automatically add the foreign key relation to the schema, but for that you need to define
+     * the fields of the related model in the fields object.
+     *
+     * For example: A User model have a field `companyId` that is a ForeignKeyField to the Company model. The `relationName`
+     * is the direct relation from the User model to the Company model, and the `relatedName` is the reverse relation from the
+     * Company model to the User model. If you define the fieldName as either the relatedName or the relationName it will fetch
+     * the data automatically.
+     *
+     * **Important**: We build the schema dynamically but also lazily, if you don't try to parse or validate the schema, it won't be built.
+     * After the first time it's built, it's cached and never built again.
+     *
+     * **Important 2**: If you want to use the automatic relation feature, you need to define guarantee that the foreignKey field fieldName
+     * exists on `show` array, or that it doesn't exist on `omit` array.
+     *
+     * Like: `{ options: { show: ['id', 'name', 'companyId'] }}` or `{ options: { omit: ['id'] }}` it **will work**.
+     *
+     * If you do `{ options: { show: ['id', 'name'] }}` or `{ options: { omit: ['companyId']} }` it **won't work**.
+     *
+     * **Important 3**: If you want to return an array instead of an object, you need to pass the `many` option as true.
+     *
+     * @example
+     * ```typescript
+     * import { auto, choice, foreignKey, Model, define } from '@palmares/databases';
+     * import * as p from '@palmares/schemas';
+     *
+     * const Company = define('Company', {
+     *   fields: {
+     *     id: auto(),
+     *     name: text(),
+     *   },
+     *   options: {
+     *     tableName: 'company',
+     *   }
+     * });
+     *
+     * class User extends Model<User>() {
+     *    fields = {
+     *     id: auto(),
+     *     type: choice({ choices: ['user', 'admin'] }),
+     *     companyId: foreignKey({
+     *        relatedTo: Company,
+     *        relationName: 'company',
+     *        relatedName: 'usersOfCompany',
+     *        toField: 'id',
+     *        onDelete: 'CASCADE',
+     *      }),
+     *   }
+     *
+     *   options = {
+     *     tableName: 'user',
+     *   }
+     * }
+     *
+     * const userSchema = p.modelSchema(User, {
+     *   fields: {
+     *      company: p.modelSchema(Company).optional({ outputOnly: true });
+     *   },
+     *   show: ['type', 'companyId']
+     * });
+     *
+     * const companySchema = p.modelSchema(Company, {
+     *   fields: {
+     *      usersOfCompany: p.modelSchema(User, { many: true }).optional({ outputOnly: true });
+     *   },
+     *   show: ['id', 'type']
+     * });
+     *```
+    * @param model - The model that you want to build the schema from.
+    * @param options - The options to build the schema.
+    * @param options.ignoreExtraneousFields - If you want to ignore extraneous fields set this to true.
+    * @param options.engineInstance - What engine instance you want to use to fetch the data. Defaults to the first one.
+    * @param options.fields - Extra fields that you want to add to the schema. If it has the same name as the model field,
+    * We will not create a schema for that field and use the one you have defined here.
+    * @param options.omit - Fields that you want to omit from the schema. If that is defined, we ignore `show` option.
+    * @param options.show - Fields that you want to show on the schema. If that is defined, we ignore `omit` option.
+    * @param options.many - If you want to return an array instead of an object, set this to true. With that we create
+    * an ArraySchema instead of an ObjectSchema.
+    *
+    * @returns - If you pass the `many` option as true, we return an ArraySchema, otherwise we return an ObjectSchema.
+    */ modelSchema: function(model, options) {
+            return (0, _model.modelSchema)(model, options);
+        }
+    };
+} /*
+export class User extends Model<User>() {
+  fields = {
+    id: AutoField.new(),
+    uuid: UuidField.new({
+      autoGenerate: true
+    }),
+    name: CharField.new({ maxLength: 255, dbIndex: true, allowNull: true }),
+    age: IntegerField.new({ dbIndex: true }),
+    userType: EnumField.new({ choices: ['admin', 'user'], defaultValue: 'admin' }),
+    price: DecimalField.new({ maxDigits: 5, decimalPlaces: 2, allowNull: true }),
+    isActive: BooleanField.new({ defaultValue: true }),
+    companyId: ForeignKeyField.new({
+      onDelete: ON_DELETE.CASCADE,
+      relatedName: 'usersOfCompany',
+      relationName: 'company',
+      toField: 'id',
+      relatedTo: Company
+    }),
+    updatedAt: DateField.new({ autoNow: true }),
+    createdAt: DateField.new({ autoNowAdd: true }),
+  }
+
+  options: ModelOptionsType<User> = {
+    tableName: 'users',
+  }
+}
+
+export class Company extends Model<Company>() {
+  fields = {
+    id: AutoField.new(),
+    name: CharField.new({ maxLength: 255 }),
+    address: CharField.new({ maxLength: 255, allowNull: true }),
+  }
+
+  options: ModelOptionsType<Company> = {
+    tableName: 'companies',
+  }
+}
+*/