@medyll/idae-mongo 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# create-svelte
+
+Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+
+Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npm create svelte@latest
+
+# create a new project in my-app
+npm create svelte@latest my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/data/Entity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Mother of dragons
+ * holds all other classes
+ */
+export declare class Entity {
+}

package/dist/data/Entity.js

@@ -0,0 +1,7 @@
+import { IIdae } from './types';
+/**
+ * Mother of dragons
+ * holds all other classes
+ */
+export class Entity {
+}

package/dist/data/SchemeFieldClass.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/data/SchemeFieldClass.js

@@ -0,0 +1,53 @@
+import { IIdae } from './types';
+class SchemeFieldClass {
+    _field_code;
+    _field_code_raw;
+    _field_name;
+    _field_name_raw;
+    _field_icon;
+    _field_type;
+    _field_group;
+    _field_order;
+    _field_name_group;
+    _viewFieldType;
+    _title;
+    _className;
+    get field_code() {
+        return this._field_code;
+    }
+    get field_name() {
+        return this._field_name;
+    }
+    get field_name_raw() {
+        return this._field_name_raw;
+    }
+    get field_code_raw() {
+        return this._field_code_raw;
+    }
+    get field_icon() {
+        return this._field_icon;
+    }
+    get field_type() {
+        return this._field_type;
+    }
+    get field_group() {
+        return this._field_group;
+    }
+    get field_order() {
+        return this._field_order;
+    }
+    get field_name_group() {
+        return this._field_name_group;
+    }
+    get viewFieldType() {
+        return this._viewFieldType;
+    }
+    get title() {
+        return this._title;
+    }
+    get className() {
+        return this._className;
+    }
+    construcor() { }
+    buildSchemeField() { }
+}

package/dist/data/SchemeModel.d.ts

@@ -0,0 +1,30 @@
+import { IIdae } from './types';
+import { ISchemeViewsList } from './schemeModelClass';
+export declare class SchemeModel {
+    private codeAppscheme;
+    private schemeModelClass;
+    private _schemeModel;
+    private _schemeViews;
+    private _schemeAssociationFields;
+    private _schemeIcon;
+    private _schemeName;
+    private _schemeCode;
+    private _schemeFieldsView;
+    private _schemeRFK;
+    private _schemeFK;
+    private _schemeModelBase;
+    constructor(codeAppscheme: IIdae.schemeCode);
+    get schemeModel(): any;
+    get schemeModelBase(): Record<string, any>;
+    get schemeCode(): IIdae.schemeCode;
+    get schemeName(): IIdae.schemeName;
+    get schemeIcon(): IIdae.schemeFieldIcon;
+    get schemeAssociationFields(): any;
+    get schemeFieldsView(): any;
+    get schemeRFK(): any;
+    get schemeFK(): any;
+    get schemeViews(): {
+        [p: string]: ISchemeViewsList;
+    };
+    private buildSchemeViews;
+}

package/dist/data/SchemeModel.js

@@ -0,0 +1,60 @@
+import { IIdae } from './types';
+import { schemeModelClassInstance, ISchemeViewsList, OptSchemeViews, ISchemeViewCode } from './schemeModelClass';
+// ENtity in DMP
+export class SchemeModel {
+    // Class AppScheme
+    codeAppscheme;
+    schemeModelClass;
+    _schemeModel;
+    _schemeViews; // <Params extends { [K in keyof Params]?: string }>
+    _schemeAssociationFields;
+    _schemeIcon;
+    _schemeName;
+    _schemeCode;
+    _schemeFieldsView;
+    _schemeRFK;
+    _schemeFK;
+    _schemeModelBase;
+    constructor(codeAppscheme) {
+        this.codeAppscheme = codeAppscheme;
+        this.schemeModelClass = schemeModelClassInstance.getInstance();
+        this._schemeViews = this.buildSchemeViews();
+    }
+    get schemeModel() {
+        return this.schemeModelClass.getSchemeModel(this.codeAppscheme);
+    }
+    get schemeModelBase() {
+        return this.schemeModelClass.getSchemeModelBase();
+    }
+    get schemeCode() {
+        return this.codeAppscheme;
+    }
+    get schemeName() {
+        return this._schemeName;
+    }
+    get schemeIcon() {
+        return this.schemeModelClass.getSchemeIcon(this.codeAppscheme);
+    }
+    get schemeAssociationFields() {
+        return this._schemeAssociationFields;
+    }
+    get schemeFieldsView() {
+        return this._schemeFieldsView;
+    }
+    get schemeRFK() {
+        return this.schemeModelClass.getGrilleRFK(this.codeAppscheme);
+    }
+    get schemeFK() {
+        return this.schemeModelClass.getGrilleFK(this.codeAppscheme);
+    }
+    get schemeViews() {
+        return this._schemeViews;
+    }
+    buildSchemeViews() {
+        const exp = {};
+        Object.values(OptSchemeViews).forEach((conf) => {
+            exp[conf] = this.schemeModelClass.getSchemeView(this.codeAppscheme, conf);
+        });
+        return exp;
+    }
+}

package/dist/data/schemeModelClass.d.ts

@@ -0,0 +1,48 @@
+import { IIdae } from './types';
+export declare enum OptSchemeViews {
+    microModel = "microModel",
+    miniModel = "miniModel",
+    fieldModel = "fieldModel",
+    defaultModel = "defaultModel",
+    columnModel = "columnModel",
+    hasModel = "hasModel"
+}
+export interface ISchemeViewsList {
+    [OptSchemeViews.fieldModel]: OptSchemeViews.fieldModel;
+    [OptSchemeViews.defaultModel]: OptSchemeViews.defaultModel;
+    [OptSchemeViews.columnModel]: OptSchemeViews.columnModel;
+    [OptSchemeViews.hasModel]: OptSchemeViews.hasModel;
+    [OptSchemeViews.miniModel]: OptSchemeViews.miniModel;
+    [OptSchemeViews.microModel]: OptSchemeViews.microModel;
+}
+export type ISchemeViewCode = keyof typeof OptSchemeViews;
+/**
+ *  TODO change name into schemeEntity ?
+ */
+export declare class schemeModelClassInstance {
+    private static instance;
+    api_schemes: Record<string, any>;
+    bundles: string[];
+    private constructor();
+    static getInstance(): schemeModelClassInstance;
+    initScheme(_data: any): void;
+    getSchemeTable(schemeCode: IIdae.schemeCode): Record<string, any>;
+    getSchemeModelBase(): Record<string, any>;
+    getSchemeModel(schemeCode: IIdae.schemeCode): any;
+    getTableAssociationFields(schemeCode?: IIdae.schemeCode): any;
+    getSchemeView(schemeCode: IIdae.schemeCode, viewName?: ISchemeViewCode): IIdae.IAppSchemeFieldModel | IIdae.IEmptyObject;
+    getGrilleRFK(schemeCode: IIdae.schemeCode): any;
+    getGrilleFK(schemeCode: IIdae.schemeCode): any;
+    getTableDefaultField(schemeCode: IIdae.schemeCode): IIdae.IAppSchemeFieldModel | Record<string, any>;
+    getTableMicroField(schemeCode: IIdae.schemeCode): any;
+    getTableEntity(schemeCode: IIdae.schemeCode): any;
+    getTableFieldsView(schemeCode: IIdae.schemeCode): IIdae.IAppSchemeFieldModel | IIdae.IEmptyObject;
+    getSchemeIcon(schemeCode: IIdae.schemeCode): IIdae.schemeFieldIcon;
+    getSchemeColor(schemeCode: IIdae.schemeCode): IIdae.schemeFieldColor;
+    getTableIdentifier(schemeCode: IIdae.schemeCode): any;
+    getSchemeName(schemeCode: IIdae.schemeCode): any;
+    getTableNameHuman(schemeCode: IIdae.schemeCode): any;
+    getSchemeBundle(schemeCode: IIdae.schemeCode): string;
+}
+declare const _default: schemeModelClassInstance;
+export default _default;

package/dist/data/schemeModelClass.js

@@ -0,0 +1,154 @@
+import { IIdae } from './types';
+export var OptSchemeViews;
+(function (OptSchemeViews) {
+    OptSchemeViews["microModel"] = "microModel";
+    OptSchemeViews["miniModel"] = "miniModel";
+    OptSchemeViews["fieldModel"] = "fieldModel";
+    OptSchemeViews["defaultModel"] = "defaultModel";
+    OptSchemeViews["columnModel"] = "columnModel";
+    OptSchemeViews["hasModel"] = "hasModel";
+})(OptSchemeViews || (OptSchemeViews = {}));
+/**
+ *  TODO change name into schemeEntity ?
+ */
+export class schemeModelClassInstance {
+    static instance;
+    api_schemes = {};
+    bundles = [];
+    constructor() { }
+    static getInstance() {
+        if (!schemeModelClassInstance.instance) {
+            schemeModelClassInstance.instance = new schemeModelClassInstance();
+        }
+        return this.instance;
+    }
+    initScheme(_data) {
+        this.api_schemes = _data;
+        this.bundles = Object.keys(_data);
+    }
+    getSchemeTable(schemeCode) {
+        return this.api_schemes;
+    }
+    getSchemeModelBase() {
+        return this.api_schemes;
+    }
+    getSchemeModel(schemeCode) {
+        if (!schemeCode)
+            return {};
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        return this.api_schemes[ownBundle][schemeCode]['entity'] || {};
+    }
+    getTableAssociationFields(schemeCode = '') {
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        return this.api_schemes[ownBundle][schemeCode].table_associations_fields;
+    }
+    getSchemeView(schemeCode, viewName = 'fieldModel') {
+        if (!schemeCode)
+            return {};
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        return this.api_schemes[ownBundle][schemeCode]['views'][viewName];
+    }
+    getGrilleRFK(schemeCode) {
+        if (!schemeCode)
+            return {};
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        const table_entity = this.getTableEntity(schemeCode);
+        const exp = Object.keys(table_entity.grilleRFK).map((entityCode) => {
+            return this.getTableEntity(entityCode);
+        });
+        return exp.reduce(function (map, obj) {
+            map[obj.codeAppscheme] = { ...obj };
+            return map;
+        }, {});
+    }
+    getGrilleFK(schemeCode) {
+        if (!schemeCode)
+            return {};
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        const table_entity = this.getTableEntity(schemeCode);
+        const exp = Object.keys(table_entity.grilleFK).map((entityCode) => {
+            return this.getTableEntity(entityCode);
+        });
+        return exp.reduce(function (map, obj) {
+            map[obj.codeAppscheme] = { ...obj };
+            return map;
+        }, {});
+    }
+    getTableDefaultField(schemeCode) {
+        return this.getSchemeView(schemeCode, 'miniModel') || {};
+    }
+    getTableMicroField(schemeCode) {
+        return this.getSchemeView(schemeCode, 'microModel') || {};
+    }
+    getTableEntity(schemeCode) {
+        if (!schemeCode)
+            return {};
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        return this.api_schemes[ownBundle][schemeCode].entity;
+    }
+    getTableFieldsView(schemeCode) {
+        if (!schemeCode)
+            return {};
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        return this.getSchemeView(schemeCode, 'miniModel') || {};
+    }
+    getSchemeIcon(schemeCode) {
+        if (!schemeCode)
+            return '';
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return '';
+        return this.api_schemes[ownBundle][schemeCode]['entity'].iconAppscheme;
+    }
+    getSchemeColor(schemeCode) {
+        if (!schemeCode)
+            return '_noschemeCode';
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return 'no_color';
+        return this.api_schemes[ownBundle][schemeCode]['entity'].colorAppscheme;
+    }
+    getTableIdentifier(schemeCode) {
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return {};
+        return this.api_schemes[ownBundle][schemeCode].table_identifier;
+    }
+    getSchemeName(schemeCode) {
+        if (!schemeCode)
+            return '';
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return '';
+        return this.api_schemes[ownBundle][schemeCode].nomAppscheme;
+    }
+    getTableNameHuman(schemeCode) {
+        if (!schemeCode)
+            return '';
+        let ownBundle = this.getSchemeBundle(schemeCode);
+        if (!ownBundle)
+            return '';
+        return this.api_schemes[ownBundle][schemeCode]['entity'].nomAppscheme;
+    }
+    getSchemeBundle(schemeCode) {
+        return (this.bundles.find((bundle) => {
+            if (this.api_schemes[bundle][schemeCode])
+                return bundle;
+        }) ?? '');
+    }
+}
+export default schemeModelClassInstance.getInstance();

package/dist/data/types.d.ts

@@ -0,0 +1,124 @@
+export type SchemeList = AppScheme[];
+export type SchemeFieldModelList = AppSchemeFieldModel[];
+export type SchemeFieldList = SchemeField[];
+export type mongoId = string;
+export type schemeId = number;
+export type schemeCode = string;
+export type schemeName = string;
+export type schemeIcon = string;
+export type schemeColor = string;
+export type schemeOrder = number;
+export type schemeFieldId = number;
+export type schemeFieldCode = string;
+export type schemeFieldCodeRaw = string;
+export type schemeFieldName = string;
+export type schemeFieldNameRaw = string;
+export type schemeFieldIcon = string;
+export type schemeFieldColor = string;
+export type schemeFieldOrder = number;
+export interface IEmptyObject {
+}
+export interface AppSchemeBase {
+    idappscheme_base: schemeId;
+    code: schemeCode;
+    name: schemeName;
+    icon?: schemeIcon;
+    color?: schemeColor;
+    order?: schemeOrder;
+    dateChanged: string;
+    timeChanged: string;
+}
+export interface AppSchemeType extends BaseBase {
+    idappscheme_type: schemeId;
+}
+type Grille<T> = Record<keyof T, {
+    id: schemeId;
+    code: schemeCode;
+    order?: schemeOrder;
+}>;
+interface BaseBase {
+    code: schemeCode;
+    name: schemeName;
+    icon?: schemeIcon;
+    color?: schemeColor;
+    order?: schemeOrder;
+    dateChanged: string;
+    timeChanged: string;
+}
+export interface AppScheme extends BaseBase, AppSchemeBase, AppSchemeType {
+    idappscheme: schemeId;
+    fk: Grille<AppScheme>;
+    grilleRFK: Grille<AppScheme>;
+    grilleCount: Grille<AppScheme>;
+}
+export interface AppSchemeField {
+    idappscheme_field: schemeFieldId;
+    idappscheme_field_group: schemeFieldId;
+    idappscheme_field_type: schemeFieldId;
+    codeAppscheme_field: schemeFieldCode;
+    nameAppscheme_field: schemeFieldName;
+    nameAppscheme_field_raw: schemeFieldNameRaw;
+    codeAppscheme_field_raw: schemeFieldCodeRaw;
+    iconAppscheme_field?: schemeFieldIcon;
+    colorAppscheme_field?: schemeFieldColor;
+    typeAppscheme_field: string;
+    groupAppscheme_field: string;
+    orderAppscheme_field?: schemeFieldOrder;
+    requiredAppscheme_field?: boolean | (() => boolean);
+    field_code: schemeFieldCode;
+    field_name: schemeFieldName;
+    field_name_raw: schemeFieldNameRaw;
+    field_code_raw: schemeFieldCodeRaw;
+    field_icon?: schemeFieldIcon;
+    field_color?: schemeFieldColor;
+    field_type: string;
+    field_group: string;
+    field_order?: schemeFieldOrder;
+    field_required?: boolean | (() => boolean);
+}
+export interface AppSchemeFieldGroup {
+    idappscheme_field_group: schemeFieldId;
+    nameAppscheme_field_group: string;
+    codeAppscheme_field_group: string;
+    orderAppscheme_field_group?: schemeFieldOrder;
+}
+export interface AppSchemeFieldType {
+    idappscheme_field_type: schemeFieldId;
+    nameAppscheme_field_type: string;
+    codeAppscheme_field_type: string;
+    orderAppscheme_field_type?: schemeFieldOrder;
+}
+export interface AppSchemeFieldModel {
+    field_code: schemeFieldCode;
+    field_name: schemeFieldName;
+    field_name_raw: schemeFieldNameRaw;
+    field_code_raw: schemeFieldCodeRaw;
+    field_icon?: schemeFieldIcon;
+    field_color?: schemeFieldColor;
+    field_type: string;
+    field_group: string;
+    field_order?: schemeFieldOrder;
+    field_required?: boolean | (() => boolean);
+}
+export interface AppschemeView extends BaseBase {
+    idappscheme_view: schemeId;
+    fields: {
+        [key: string]: {
+            order: schemeFieldOrder;
+            schemeCode: schemeCode;
+            schemeFieldCode: schemeFieldCode;
+            transform: () => void;
+        };
+    };
+}
+export interface SchemeField {
+    _id: mongoId;
+    [index: string]: schemeFieldId | string;
+}
+export interface IDataset {
+    [key: string]: SchemeField;
+}
+export interface IResultSet {
+    [key: mongoId]: IDataset;
+}
+export {};

package/dist/data/types.js

@@ -0,0 +1,9 @@
+class Typed {
+    _type;
+    _description;
+    _extends;
+    _omit;
+}
+function doTyped(args, _t) { }
+let a = doTyped(125, 'keyof AppSchemeBase');
+export {};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './data/types.js';
+export * from './data/schemeModelClass.js';
+export * from './data/SchemeModel.js';
+export * from './data/SchemeFieldClass.js';
+export * from './data/Entity.js';

package/dist/index.js

@@ -0,0 +1,6 @@
+// Reexport of entry components
+export * from './data/types.js';
+export * from './data/schemeModelClass.js';
+export * from './data/SchemeModel.js';
+export * from './data/SchemeFieldClass.js';
+export * from './data/Entity.js';

package/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@medyll/idae-mongo",
+	"version": "0.1.0",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run package",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"prepublishOnly": "npm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"test": "vitest",
+		"lint": "prettier --check . && eslint .",
+		"format": "prettier --write .",
+		"package:pre": "node scripts/package-pre.js"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"peerDependencies": {
+		"svelte": "^5.0.0-next"
+	},
+	"devDependencies": {
+		"@sveltejs/adapter-auto": "^3.0.0",
+		"@sveltejs/kit": "^2.0.0",
+		"@sveltejs/package": "^2.0.0",
+		"@sveltejs/vite-plugin-svelte": "^3.0.0",
+		"@types/eslint": "^9.6.0",
+		"eslint": "^9.0.0",
+		"eslint-config-prettier": "^9.1.0",
+		"eslint-plugin-svelte": "^2.36.0",
+		"globals": "^15.0.0",
+		"prettier": "^3.1.1",
+		"prettier-plugin-svelte": "^3.1.2",
+		"svelte": "^5.0.0-next.218",
+		"svelte-check": "^3.8.5",
+		"typescript": "^5.0.0",
+		"typescript-eslint": "^8.0.0",
+		"vite": "^5.0.11",
+		"vitest": "^2.0.0"
+	},
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"scope": "@medyll"
+}