@postxl/schema 0.0.2

package/dist/model/model.json-decoder.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export declare const zModelNameJSON: z.ZodEffects<z.ZodString, string, string>;
+export declare const zModelJSON: z.ZodEffects<z.ZodObject<{
+    name: z.ZodEffects<z.ZodString, string, string>;
+    description: z.ZodOptional<z.ZodString>;
+    isReadonly: z.ZodOptional<z.ZodBoolean>;
+    schema: z.ZodOptional<z.ZodString>;
+    databaseName: z.ZodOptional<z.ZodString>;
+    excelName: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>, "many">>;
+    standardFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    defaultField: z.ZodOptional<z.ZodString>;
+    labelField: z.ZodOptional<z.ZodString>;
+    indexes: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodBranded<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, "PXL.FieldName">, "many">, "many">>;
+    seed: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    source: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    faker: z.ZodOptional<z.ZodObject<{
+        items: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        seed?: number | undefined;
+        items?: number | undefined;
+    }, {
+        seed?: number | undefined;
+        items?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: {
+        seed?: number | undefined;
+        items?: number | undefined;
+    } | undefined;
+    seed?: any[] | undefined;
+    fields?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[] | undefined;
+    standardFields?: string[] | undefined;
+    defaultField?: string | undefined;
+    labelField?: string | undefined;
+    indexes?: (string & z.BRAND<"PXL.FieldName">)[][] | undefined;
+    source?: Record<string, unknown> | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: {
+        seed?: number | undefined;
+        items?: number | undefined;
+    } | undefined;
+    seed?: any[] | undefined;
+    fields?: z.objectInputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[] | undefined;
+    standardFields?: string[] | undefined;
+    defaultField?: string | undefined;
+    labelField?: string | undefined;
+    indexes?: string[][] | undefined;
+    source?: Record<string, unknown> | undefined;
+}>, {
+    name: string;
+    description?: string | undefined;
+    schema?: string | undefined;
+    databaseName?: string | undefined;
+    excelName?: string | undefined;
+    isReadonly?: boolean | undefined;
+    faker?: {
+        seed?: number | undefined;
+        items?: number | undefined;
+    } | undefined;
+    seed?: any[] | undefined;
+    fields?: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[] | undefined;
+    standardFields?: string[] | undefined;
+    defaultField?: string | undefined;
+    labelField?: string | undefined;
+    indexes?: (string & z.BRAND<"PXL.FieldName">)[][] | undefined;
+    source?: Record<string, unknown> | undefined;
+}, unknown>;
+export type ModelJSON = z.infer<typeof zModelJSON>;

package/dist/model/model.json-decoder.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zModelJSON = exports.zModelNameJSON = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const brands_1 = require("../field/shared/brands");
+exports.zModelNameJSON = zod_1.z
+    //
+    .string()
+    .min(1, 'Name of the model must not be empty')
+    .refine((name) => name !== (0, utils_1.pluralize)(name), (name) => ({
+    message: `Model ${name} must not be pluralized!`,
+}))
+    .describe('Name of the model.');
+exports.zModelJSON = zod_1.z.preprocess((input) => {
+    if (typeof input === 'object' && input !== null) {
+        const original = input;
+        const result = { ...original, source: { ...original } };
+        return result;
+    }
+    return input;
+}, zod_1.z.object({
+    name: exports.zModelNameJSON,
+    description: zod_1.z
+        //
+        .string()
+        .optional()
+        .describe('A helpful description of the model.'),
+    isReadonly: zod_1.z
+        //
+        .boolean()
+        .optional()
+        .describe(`Indicates if the model is readonly. To be used for system models that should not be editable through actions (e.g. Mutation, Action).`),
+    //
+    schema: zod_1.z
+        //
+        .string()
+        .min(1, 'Schema of the model must not be empty')
+        .optional().describe(`The database schema that the model belongs to. 
+If not provided, the default data schema is assumed.`),
+    databaseName: zod_1.z
+        .string()
+        .optional()
+        .describe('Mapping of the model to a database table name. If not provided, we use the snakecase of `name` field.'),
+    excelName: zod_1.z
+        .string()
+        .optional()
+        .refine((name) => name === undefined || name === (0, utils_1.toExcelTableName)(name), (name) => ({
+        message: `Excel table name "${(0, utils_1.red)(name ?? '')}" is not a valid Excel table name. It must start with a letter or underscore and can only contain letters, numbers, and underscores.`,
+    }))
+        .describe('Mapping of the model to an Excel table name. If not provided, we use the `name` field.'),
+    fields: zod_1.z
+        //
+        .array(
+    // We decode the fields only to `Array<{name: string & object}>` for now, as we need to know the model names and enum names
+    zod_1.z.object({ name: zod_1.z.string() }).passthrough())
+        .optional()
+        .describe('The fields of the model.'),
+    standardFields: zod_1.z
+        //
+        .array(zod_1.z.string())
+        .optional().describe(`Names of standard fields that should be included in the model.
+Currently, the following fields are supported: id, createdAt, updatedAt, name.
+If not provided, all fields are included by default.
+
+If any of the standard fields are also provided in the \`fields\` array, the custom fields will take precedence.`),
+    defaultField: zod_1.z
+        //
+        .string()
+        .optional().describe(`Identifies one of the fields as the default field.
+The default field must be a boolean field and have exactly one entry set to \`true\`.
+The entity with this will be exposed as the default entity.
+
+Example use case: default language, root region in region tree.`),
+    labelField: zod_1.z
+        //
+        .string()
+        .optional().describe(`The name of the field that is used in the UI as the label of the entity.
+The label field must be a string field. If not provided, the \`name\` field is used as the label.`),
+    indexes: zod_1.z
+        //
+        .array(zod_1.z.array(brands_1.zFieldName).min(2))
+        .optional()
+        .describe('Each entry is an array of field names that are used to create an index.'),
+    seed: zod_1.z
+        .array(zod_1.z.any())
+        .optional()
+        .describe(`The seed data for the model. This must be a valid JSON object that corresponds to the model.`),
+    source: zod_1.z
+        .record(zod_1.z.string(), zod_1.z.unknown())
+        .optional()
+        .describe(`Contains the source definition of the model before any transformation or validation. This way, custom generators can extract/define additional information from the model.`),
+    faker: zod_1.z
+        .object({
+        items: zod_1.z
+            .number()
+            .int()
+            .optional()
+            .describe('The number of items to generate for the model. If nothing is provided, we default to 10 - unless a seed is provided, then we default to 0'),
+        seed: zod_1.z
+            .number()
+            .int()
+            .optional()
+            .describe('The seed value used to generate the data. Can be modified to generate different data.'),
+    })
+        .optional(),
+}));

package/dist/model/model.transformer.d.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import type { ModelJSON } from './model.json-decoder';
+export declare function modelJSONTransformer(input: ModelJSON, ctx: z.RefinementCtx): {
+    fields: Record<string & z.BRAND<"PXL.FieldName">, unknown>;
+    /**
+     * We also provide a list of field names to keep the original order
+     */
+    fieldNames: (string & z.BRAND<"PXL.FieldName">)[];
+    name: string & z.BRAND<"PXL.ModelName">;
+    schema: (string & z.BRAND<"PXL.DatabaseSchemaName">) | undefined;
+    databaseName: string & z.BRAND<"PXL.DatabaseModelName">;
+    defaultFieldName: (string & z.BRAND<"PXL.FieldName">) | undefined;
+    labelFieldName: (string & z.BRAND<"PXL.FieldName">) | undefined;
+    isReadonly: boolean;
+    excelName: string;
+    description: string;
+    indexes: (string & z.BRAND<"PXL.FieldName">)[][];
+    seed: any[];
+    faker: {
+        seed: number;
+        items: number;
+    };
+    source?: Record<string, unknown> | undefined;
+};
+export type ModelEnriched = ReturnType<typeof modelJSONTransformer>;
+declare function addDefaults({ description, fields, standardFields, seed, faker, ...input }: ModelJSON): {
+    isReadonly: boolean;
+    databaseName: string;
+    excelName: string;
+    description: string;
+    fields: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[];
+    standardFields: string[];
+    indexes: (string & z.BRAND<"PXL.FieldName">)[][];
+    seed: any[];
+    faker: {
+        seed: number;
+        items: number;
+    };
+    name: string;
+    schema?: string | undefined;
+    defaultField?: string | undefined;
+    labelField?: string | undefined;
+    source?: Record<string, unknown> | undefined;
+};
+type WithDefaults = ReturnType<typeof addDefaults>;
+declare function brandModel({ name, schema, databaseName, standardFields, defaultField, labelField, ...input }: WithDefaults): {
+    name: string & z.BRAND<"PXL.ModelName">;
+    schema: (string & z.BRAND<"PXL.DatabaseSchemaName">) | undefined;
+    databaseName: string & z.BRAND<"PXL.DatabaseModelName">;
+    standardFields: (string & z.BRAND<"PXL.FieldName">)[];
+    defaultFieldName: (string & z.BRAND<"PXL.FieldName">) | undefined;
+    labelFieldName: (string & z.BRAND<"PXL.FieldName">) | undefined;
+    isReadonly: boolean;
+    excelName: string;
+    description: string;
+    fields: z.objectOutputType<{
+        name: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">[];
+    indexes: (string & z.BRAND<"PXL.FieldName">)[][];
+    seed: any[];
+    faker: {
+        seed: number;
+        items: number;
+    };
+    source?: Record<string, unknown> | undefined;
+};
+type BrandedModel = ReturnType<typeof brandModel>;
+declare function combineFields({ fields, standardFields, ...model }: BrandedModel, ctx: z.RefinementCtx): {
+    fields: Record<string & z.BRAND<"PXL.FieldName">, unknown>;
+    /**
+     * We also provide a list of field names to keep the original order
+     */
+    fieldNames: (string & z.BRAND<"PXL.FieldName">)[];
+    name: string & z.BRAND<"PXL.ModelName">;
+    schema: (string & z.BRAND<"PXL.DatabaseSchemaName">) | undefined;
+    databaseName: string & z.BRAND<"PXL.DatabaseModelName">;
+    defaultFieldName: (string & z.BRAND<"PXL.FieldName">) | undefined;
+    labelFieldName: (string & z.BRAND<"PXL.FieldName">) | undefined;
+    isReadonly: boolean;
+    excelName: string;
+    description: string;
+    indexes: (string & z.BRAND<"PXL.FieldName">)[][];
+    seed: any[];
+    faker: {
+        seed: number;
+        items: number;
+    };
+    source?: Record<string, unknown> | undefined;
+};
+export type CombinedFields = ReturnType<typeof combineFields>;
+export {};

package/dist/model/model.transformer.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelJSONTransformer = modelJSONTransformer;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+const Field = __importStar(require("../field"));
+const project_schema_brands_1 = require("../project-schema/project-schema.brands");
+const model_brands_1 = require("./model.brands");
+function modelJSONTransformer(input, ctx) {
+    const withDefaults = addDefaults(input);
+    const withBranded = brandModel(withDefaults);
+    const withCombinedFields = combineFields(withBranded, ctx);
+    validateIndexes(withCombinedFields, ctx);
+    validateSeedData(withCombinedFields, ctx);
+    return withCombinedFields;
+}
+function addDefaults({ description, fields, standardFields, seed, faker, ...input }) {
+    return {
+        ...input,
+        isReadonly: input.isReadonly ?? false,
+        databaseName: input.databaseName ?? (0, utils_1.toSnakeCase)(input.name),
+        excelName: input.excelName ?? (0, utils_1.toExcelColumnName)((0, utils_1.toPascalCase)((0, utils_1.pluralize)(input.name))),
+        description: description ?? '',
+        fields: fields ?? [],
+        standardFields: standardFields ?? Field.standardFieldNames,
+        indexes: input.indexes ?? [],
+        seed: seed ?? [],
+        faker: {
+            seed: faker?.seed ?? 0,
+            // We use the provided number of faker items - if nothing is provided, we default to 10 - unless a seed is provided, then we default to 0
+            items: faker?.items ?? (seed !== undefined ? 0 : 10),
+        },
+    };
+}
+function brandModel({ name, schema, databaseName, standardFields, defaultField, labelField, ...input }) {
+    return {
+        ...input,
+        name: (0, model_brands_1.toModelName)(name),
+        schema: schema ? (0, project_schema_brands_1.toDatabaseSchemaName)(schema) : undefined,
+        databaseName: (0, model_brands_1.toDatabaseModelName)(databaseName),
+        standardFields: standardFields.map((f) => Field.toFieldName(f)),
+        defaultFieldName: defaultField ? Field.toFieldName(defaultField) : undefined,
+        labelFieldName: labelField ? Field.toFieldName(labelField) : undefined,
+    };
+}
+function combineFields({ fields, standardFields, ...model }, ctx) {
+    const standardFieldsSelected = [];
+    for (const standardFieldName of standardFields) {
+        if (fields.find((f) => f.name === standardFieldName)) {
+            // A more specific field has been defined, we skip the standard field
+            continue;
+        }
+        const standardFieldInput = Field.standardFields[standardFieldName];
+        if (!standardFieldInput) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Standard field ${standardFieldName} is not defined! Can only be one of "${Field.standardFieldNames.join('", "')}"!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        standardFieldsSelected.push(standardFieldInput);
+    }
+    const fieldsRecord = {};
+    const fieldNames = [];
+    for (const field of [...standardFieldsSelected, ...fields]) {
+        const fieldName = Field.toFieldName(field.name);
+        if (fieldsRecord[fieldName] !== undefined) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Field ${fieldName} is defined  multiple times in model ${model.name}!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        fieldsRecord[fieldName] = field;
+        fieldNames.push(fieldName);
+    }
+    if (Object.keys(fieldsRecord).length === 0) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Model ${model.name} has no fields! At least one field is required, either by standard fields or by custom fields.`,
+        });
+        return zod_1.z.NEVER;
+    }
+    return {
+        ...model,
+        fields: fieldsRecord,
+        /**
+         * We also provide a list of field names to keep the original order
+         */
+        fieldNames,
+    };
+}
+function validateIndexes({ fields, indexes, ...model }, ctx) {
+    const checkedIndexes = new Set();
+    for (const index of indexes) {
+        for (const fieldName of index) {
+            if (!fields[fieldName]) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Index [${index.join(',')} ]in model ${model.name} references unknown field ${fieldName}!`,
+                });
+                return zod_1.z.NEVER;
+            }
+        }
+        const indexName = index.toSorted((a, b) => a.localeCompare(b)).join(',');
+        if (checkedIndexes.has(indexName)) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: `Index ${indexName} in model ${model.name} is defined multiple times!`,
+            });
+            return zod_1.z.NEVER;
+        }
+        checkedIndexes.add(indexName);
+    }
+}
+function validateSeedData({ seed, fields, ...model }, ctx) {
+    if (seed.length === 0) {
+        return;
+    }
+    const fieldNames = Object.keys(fields);
+    let index = 0;
+    let hasError = false;
+    for (const seedEntry of seed) {
+        index++;
+        const entryName = seedEntry.id ? `id "${seedEntry.id}" (row ${index})` : `row #${index}`;
+        for (const fieldName of Object.keys(seedEntry)) {
+            if (!fieldNames.includes(fieldName)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Seed entry ${entryName} in model ${model.name} references unknown field "${fieldName}"!`,
+                });
+                hasError = true;
+            }
+        }
+        for (const [fieldName, field] of Object.entries(fields)) {
+            const { type, isCreatedAt, isUpdatedAt } = field;
+            const isRequired = !type.endsWith('?') && !isCreatedAt && !isUpdatedAt;
+            if (isRequired && !(fieldName in seedEntry)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Seed entry ${entryName} in model ${model.name} lacks required field "${fieldName}"!`,
+                });
+                hasError = true;
+            }
+        }
+    }
+    if (hasError) {
+        return zod_1.z.NEVER;
+    }
+}

package/dist/model/model.types.d.ts

@@ -0,0 +1,37 @@
+import * as Field from '../field';
+import { DatabaseSchemaName } from '../project-schema/project-schema.brands';
+import * as Branded from './model.brands';
+export type Models = Map<Branded.ModelName, Model>;
+export type Model = {
+    name: Branded.ModelName;
+    description: string;
+    isReadonly: boolean;
+    databaseSchema: DatabaseSchemaName;
+    databaseName: string;
+    excelName: string;
+    fields: Field.Fields;
+    idField: Field.FieldId;
+    defaultField: Field.FieldDatabaseNative | undefined;
+    labelField: Field.FieldDatabaseNative;
+    indexes: ModelIndex[];
+    seed: Seed[];
+    /**
+     * The source definition of the model. Provided to allow custom generators to extract/define additional information.
+     */
+    source?: Record<string, unknown> | undefined;
+    /**
+     * The seed data configuration for the model.
+     */
+    faker?: {
+        /**
+         * The seed value used to generate the data. Can be modified to generate different data.
+         */
+        seed: number;
+        /**
+         * The number of items to generate for the model.
+         */
+        items: number;
+    };
+};
+export type ModelIndex = Field.FieldName[];
+export type Seed = Record<string, unknown>;

package/dist/model/model.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/project-schema/project-schema.brands.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const zProjectSchemaName: z.ZodBranded<z.ZodString, "PXL.ProjectSchemaName">;
+export type ProjectSchemaName = z.infer<typeof zProjectSchemaName>;
+export declare const toProjectSchemaName: (input: string) => string & z.BRAND<"PXL.ProjectSchemaName">;
+export declare const zProjectSlug: z.ZodBranded<z.ZodEffects<z.ZodString, string, string>, "PXL.ProjectSlug">;
+export type ProjectSlug = z.infer<typeof zProjectSlug>;
+export declare const toProjectSlug: (input: string) => string & z.BRAND<"PXL.ProjectSlug">;
+export declare const zDatabaseSchemaName: z.ZodBranded<z.ZodString, "PXL.DatabaseSchemaName">;
+export type DatabaseSchemaName = z.infer<typeof zDatabaseSchemaName>;
+export declare const toDatabaseSchemaName: (input: string) => string & z.BRAND<"PXL.DatabaseSchemaName">;

package/dist/project-schema/project-schema.brands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDatabaseSchemaName = exports.zDatabaseSchemaName = exports.toProjectSlug = exports.zProjectSlug = exports.toProjectSchemaName = exports.zProjectSchemaName = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@postxl/utils");
+exports.zProjectSchemaName = zod_1.z.string().brand('PXL.ProjectSchemaName');
+const toProjectSchemaName = (input) => exports.zProjectSchemaName.parse(input);
+exports.toProjectSchemaName = toProjectSchemaName;
+exports.zProjectSlug = zod_1.z
+    .string()
+    .refine(utils_1.isSlug, (s) => ({ message: `Project slug must be a valid slug. Expected ${(0, utils_1.slugify)(s)}, received ${s}` }))
+    .brand('PXL.ProjectSlug');
+const toProjectSlug = (input) => exports.zProjectSlug.parse(input);
+exports.toProjectSlug = toProjectSlug;
+exports.zDatabaseSchemaName = zod_1.z.string().brand('PXL.DatabaseSchemaName');
+const toDatabaseSchemaName = (input) => exports.zDatabaseSchemaName.parse(input);
+exports.toDatabaseSchemaName = toDatabaseSchemaName;

package/dist/project-schema/project-schema.defaults.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The name of the default data schema of the project.
+ * This name is used when a model does not specify a schema.
+ */
+export declare const databaseSchemaNameData: string & import("zod").BRAND<"PXL.DatabaseSchemaName">;
+/**
+ * The name of the schema that contains the configuration of the project.
+ */
+export declare const databaseSchemaNameConfig: string & import("zod").BRAND<"PXL.DatabaseSchemaName">;
+export declare const defaultSystemUser: {
+    id: string;
+    sub: null;
+    email: string;
+    name: string;
+    profilePictureUrl: string;
+};

package/dist/project-schema/project-schema.defaults.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSystemUser = exports.databaseSchemaNameConfig = exports.databaseSchemaNameData = void 0;
+const Branded = __importStar(require("./project-schema.brands"));
+/**
+ * The name of the default data schema of the project.
+ * This name is used when a model does not specify a schema.
+ */
+exports.databaseSchemaNameData = Branded.toDatabaseSchemaName('Data');
+/**
+ * The name of the schema that contains the configuration of the project.
+ */
+exports.databaseSchemaNameConfig = Branded.toDatabaseSchemaName('PXL');
+exports.defaultSystemUser = {
+    id: 'root',
+    sub: null,
+    email: 'admin@postxl.com',
+    name: 'Root',
+    profilePictureUrl: 'https://postxl.com/images/team/user.png',
+};