tungsten 0.2.1 → 0.2.3

package/dist/auth/passwordHashing.sxyt.js

@@ -0,0 +1,46 @@
+import { describe } from 'sxy-test-runner';
+import { expect } from 'chai';
+import { hashPassword, hashPasswordBytes } from "./hashPassword.js";
+import { checkPassword, checkPasswordBytes } from "./checkPassword.js";
+describe('hashPassword()', ({
+  it
+}) => {
+  it('hashes a password and returns a string', async () => {
+    const hashed = await hashPassword('abcd');
+    console.log('hashed: ' + hashed);
+    expect(hashed).to.be.a('string');
+    expect(hashed.length).to.be.at.least(10);
+  });
+});
+describe('hashPasswordBytes()', ({
+  it
+}) => {
+  it('hashes a password and returns an array of bytes', async () => {
+    const hashedBytes = await hashPasswordBytes('abcd');
+    expect(hashedBytes).to.be.an.instanceOf(Buffer);
+    const hashedString = hashedBytes.toString();
+    console.log('hashedString: ' + hashedString);
+    expect(hashedString).to.be.a('string');
+    expect(hashedString.length).to.be.at.least(10);
+  });
+});
+describe('checkPassword()', ({
+  it
+}) => {
+  it('It states whether a password matches the input', async () => {
+    const password = 'xyz';
+    const hashed = await hashPassword(password);
+    expect(await checkPassword(password, hashed)).to.equal(true);
+    expect(await checkPassword(password + 'NotOurPassword', hashed)).to.equal(false);
+  });
+});
+describe('checkPasswordBytes()', ({
+  it
+}) => {
+  it('It states whether a password matches the input', async () => {
+    const password = 'xyz';
+    const hashed = await hashPasswordBytes(password);
+    expect(await checkPasswordBytes(password, hashed)).to.equal(true);
+    expect(await checkPasswordBytes(password + 'NotOurPassword', hashed)).to.equal(false);
+  });
+});

package/dist/auth/ref/auth.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth/ref/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/auth/ref/auth.ts"],"names":[],"mappings":""}

package/dist/auth/ref/auth.js

@@ -0,0 +1,23 @@
+// export function doLogIn(req, user) {
+//     req.session.loggedIn = true
+//     req.session.userId = user.id
+//     req.session.userType = user.type
+export {};
+//     //console.log('session after doLogIn', req.session)
+// }
+// export function doLogOut(req) {
+//     req.session.loggedIn = false
+//     delete req.session.userId
+//     delete req.session.userType
+// }
+// export function permittedToUseBackendReq(req) {
+//     return req.session.loggedIn && permittedToUseBackend({ type: req.session.userType })
+// }
+// export function permittedToUseBackend(user) {
+//     return [
+//         'administrator',
+//         'editor',
+//         'writer',
+//         'guest'
+//     ].includes(user.type)
+// }

package/dist/auth/ref/checkPasswordResetToken.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkPasswordResetToken.d.ts.map

package/dist/auth/ref/checkPasswordResetToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPasswordResetToken.d.ts","sourceRoot":"","sources":["../../../src/auth/ref/checkPasswordResetToken.ts"],"names":[],"mappings":""}

package/dist/auth/ref/checkPasswordResetToken.js

@@ -0,0 +1,27 @@
+// import crypto from 'crypto'
+// import { PasswordResetToken } from '../models/PasswordResetToken.js'
+export {};
+// export async function checkPasswordResetToken(user, token: string) {
+//     const hash = crypto.createHash('sha256').update(user.id + token).digest('base64url')
+//     const passwordResetToken
+//         = await PasswordResetToken.find({
+//             userId: user.id,
+//             hash
+//         })
+//     if (passwordResetToken === null) {
+//         return {
+//             success: false,
+//             reason: 'Invalid'
+//         }
+//     } else if (passwordResetToken.expiresAt < new Date()) {
+//         return {
+//             success: false,
+//             reason: 'Expired'
+//         }
+//     } else {
+//         return {
+//             success: true,
+//             reason: 'Valid'
+//         }
+//     }
+// }

package/dist/auth/ref/checkPasswordResetToken.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkPasswordResetToken.sxyt.d.ts.map

package/dist/auth/ref/checkPasswordResetToken.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkPasswordResetToken.sxyt.d.ts","sourceRoot":"","sources":["../../../src/auth/ref/checkPasswordResetToken.sxyt.js"],"names":[],"mappings":""}

package/dist/auth/ref/checkPasswordResetToken.sxyt.js

@@ -0,0 +1,40 @@
+// import { describe } from 'sxy-test-runner'
+// import crypto from 'crypto'
+export {};
+// import { PasswordResetToken } from '../models/PasswordResetToken'
+// import { prisma } from '../prisma/client'
+// import { checkPasswordResetToken } from './checkPasswordResetToken.js'
+// import { createPasswordResetToken } from './createPasswordResetToken.js'
+// describe('checkPasswordResetToken() function', async ({it}) => {
+//     const user = await prisma.user.findFirst({ where: { id: 1 } })
+//     it('fails with junk data', async () => {
+//         const user = await prisma.user.findFirst({ where: { id: 1 } })
+//         const result = await checkPasswordResetToken(user, 'junk')
+//         result.success.should.equal(false)
+//         result.reason.should.equal('Invalid')
+//     })
+//     it('succeeds with a valid token', async () => {
+//         //const user = await prisma.user.findFirst({ where: { id: 1 } })
+//         const token = await createPasswordResetToken(user)
+//         //console.log('test token', token)
+//         const result = await checkPasswordResetToken(user, token)
+//         result.success.should.equal(true)
+//         result.reason.should.equal('Valid')
+//     })
+//     it('fails with an outdated token', async () => {
+//         //const user = await prisma.user.findFirst({ where: { id: 1 } })
+//         const token = 'abcde'
+//         const hash = crypto.createHash('sha256').update(user.id + token).digest('base64url')
+//         const passwordResetToken = new PasswordResetToken
+//         passwordResetToken.userId = user.id
+//         passwordResetToken.hash = hash
+//         passwordResetToken.expiresAt = new Date(Date.now() - 99999)
+//         await passwordResetToken.create()
+//         const result = await checkPasswordResetToken(user, token)
+//         result.success.should.equal(false)
+//         result.reason.should.equal('Expired')
+//         await prisma.passwordResetToken.delete({ where: {
+//             id: passwordResetToken.id
+//         } })
+//     })
+// })

package/dist/auth/ref/createPasswordResetToken.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createPasswordResetToken.d.ts.map

package/dist/auth/ref/createPasswordResetToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPasswordResetToken.d.ts","sourceRoot":"","sources":["../../../src/auth/ref/createPasswordResetToken.ts"],"names":[],"mappings":""}

package/dist/auth/ref/createPasswordResetToken.js

@@ -0,0 +1,19 @@
+// import crypto from 'crypto'
+// import { PasswordResetToken } from '../models/PasswordResetToken.js'
+export {};
+// export function createPasswordResetToken(user) {
+//     return new Promise( (resolve, reject) => {
+//         crypto.randomBytes(16, async (err, buffer) => {
+//             if (err) reject(err)
+//             const token = buffer.toString('base64url')
+//             const hash = crypto.createHash('sha256').update(user.id + token).digest('base64url')
+//             const passwordResetToken = new PasswordResetToken
+//             passwordResetToken.userId = user.id
+//             passwordResetToken.hash = hash
+//             const _1HourInMs = 1000*60*60
+//             passwordResetToken.expiresAt = new Date(Date.now() + _1HourInMs)
+//             await passwordResetToken.create()
+//             resolve(token)
+//         })
+//     })
+// }

package/dist/auth/ref/createPasswordResetToken.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createPasswordResetToken.sxyt.d.ts.map

package/dist/auth/ref/createPasswordResetToken.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPasswordResetToken.sxyt.d.ts","sourceRoot":"","sources":["../../../src/auth/ref/createPasswordResetToken.sxyt.js"],"names":[],"mappings":""}

package/dist/auth/ref/createPasswordResetToken.sxyt.js

@@ -0,0 +1,10 @@
+// import { describe } from 'sxy-test-runner'
+// import { prisma } from '../prisma/client'
+// import { createPasswordResetToken } from './createPasswordResetToken.js'
+export {};
+// describe('createPasswordResetToken() function', ({it}) => {
+//     it('creates a reset token and saves it to the database', async () => {
+//         const user = await prisma.user.findFirst({ where: { id: 1 } })
+//         createPasswordResetToken(user)
+//     })
+// })

package/dist/babelPlugins/BabelFakeType.d.ts

@@ -0,0 +1,7 @@
+import { parse } from '@babel/core';
+import type * as BabelTypes from '@babel/types';
+export type BabelFake = {
+    types: typeof BabelTypes;
+    parse: typeof parse;
+};
+//# sourceMappingURL=BabelFakeType.d.ts.map

package/dist/babelPlugins/BabelFakeType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelFakeType.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelFakeType.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,OAAO,KAAK,KAAK,UAAU,MAAM,cAAc,CAAA;AAE/C,MAAM,MAAM,SAAS,GAAG;IACpB,KAAK,EAAE,OAAO,UAAU,CAAA;IACxB,KAAK,EAAE,OAAO,KAAK,CAAA;CACtB,CAAA"}

package/dist/babelPlugins/BabelFakeType.js

@@ -0,0 +1,3 @@
+// //import {  } from '@babel/types/lib/builders/generated/index.js'
+// //import { type } from '@babel/generator'
+export {};

package/dist/babelPlugins/BabelState.type.d.ts

@@ -0,0 +1,3 @@
+import type { BabelFile } from '@babel/core';
+export type BabelState = BabelFile;
+//# sourceMappingURL=BabelState.type.d.ts.map

package/dist/babelPlugins/BabelState.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelState.type.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelState.type.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C,MAAM,MAAM,UAAU,GAAG,SAAS,CAAA"}

package/dist/babelPlugins/BabelState.type.js

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

package/dist/babelPlugins/BabelTransformBindDirect.d.ts

@@ -0,0 +1,9 @@
+import { NodePath, PluginPass, types } from '@babel/core';
+import { BabelFake } from './BabelFakeType.js';
+export declare function MakeBabelTransformBindDirect(): (babel: BabelFake) => {
+    name: string;
+    visitor: {
+        JSXAttribute(path: NodePath<types.JSXAttribute>, state: PluginPass): void;
+    };
+};
+//# sourceMappingURL=BabelTransformBindDirect.d.ts.map

package/dist/babelPlugins/BabelTransformBindDirect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformBindDirect.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformBindDirect.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAGzD,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AA0C9C,wBAAgB,4BAA4B,KACC,OAAO,SAAS;;;2BAK1B,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,UAAU;;EA2VjF"}

package/dist/babelPlugins/BabelTransformBindDirect.js

@@ -0,0 +1,214 @@
+//import { T } from '@babel/core'
+import { TungstenError } from "../TungstenError.js";
+import { throwError } from "../throwError.js";
+// BabelTransformBind
+// exports MakeBabelTransformBind (function)
+//
+// 
+const bindPropName = 'bind';
+function ExistingJsxAttributeValueIsExpressionContainer(v) {
+  return v.type === 'JSXExpressionContainer';
+}
+function ExpressionIsThisExpressionOrMemberExpression(expression) {
+  return expression.type === 'ThisExpression' || expression.type === 'MemberExpression';
+}
+function ExpressionIsIdentifier(expression) {
+  return expression.type === 'Identifier';
+}
+function NodeIsPrivateName(node) {
+  return node.type === 'PrivateName';
+}
+function AssertNodeIsJSXOpeningElement(node) {
+  if (node.type !== 'JSXOpeningElement') {
+    throw new TungstenError(`Node ${node} was not a JSXOpeningElement`);
+  }
+}
+export function MakeBabelTransformBindDirect(/*opts: Opts*/
+) {
+  return function BabelTransformBindDirect(babel) {
+    const make = babel.types;
+    return {
+      name: 'ast-transform',
+      // not required
+      visitor: {
+        JSXAttribute(path, state) {
+          if (path.node.name.name === bindPropName) {
+            if (!path.node.value) {
+              throw new TungstenError(`BabelTransformBind() error: bind prop is empty`);
+            }
+            const attributeValue = path.node.value;
+            if (!ExistingJsxAttributeValueIsExpressionContainer(attributeValue)) {
+              throw new TungstenError(`BabelTransformBind() error: bind prop should be an expression: {xxx}`);
+            }
+            if (attributeValue.expression.type !== 'MemberExpression') {
+              throw new TungstenError(`BabelTransformBind() error: bind prop should be member expression, e.g. {a.y}`);
+            }
+            const originalVariable = attributeValue.expression;
+            const variablePartsTemp = [];
+            let remaining = originalVariable;
+            while (remaining.type === 'MemberExpression') {
+              variablePartsTemp.push(remaining);
+              // {
+              //     property: remaining.property,
+              //     computed: remaining.computed,
+              // })
+              if (!ExpressionIsThisExpressionOrMemberExpression(remaining.object)) {
+                throw new TungstenError(`BabelTransformBind error: expected object in` + ` bind value to be ThisExpression or MemberExpression.` + ` Bind value must be a property on this, e.g. bind={this.foo}.` + ` Got ${remaining.object.type}: ${remaining.object}}`);
+              }
+              remaining = remaining.object;
+            }
+            // if (remaining.type !== 'ThisExpression') {
+            //     throw new Error(
+            //         'Babel Plugin Transform Bind Error:'
+            //             + ' the base of a variable passed to bind={} should be this, e.g. {this.foo}'
+            //             + ` Received ${remaining.name.name} instead`
+            //             + `\nfile: ${state.filename}`
+            //     )
+            // }
+            variablePartsTemp.push(remaining);
+            if (variablePartsTemp.length === 0) {
+              throw new Error('Babel Plugin Transform Bind Error:' + ' bind={} did not find a valid variable to bind.' + ' A state variable such as foo should be passed for this.state.foo,' + ' or foo.bar for this.state.foo.bar.' + `\nfile: ${state.filename}`);
+            }
+            variablePartsTemp.reverse();
+            if (variablePartsTemp.length < 2 || variablePartsTemp[0]?.type !== 'ThisExpression' || variablePartsTemp[1]?.type !== 'MemberExpression') {
+              throwError('BabelTransformBindDirect', 'bind target must be a member-expression path rooted at this');
+            }
+            const variableParts = variablePartsTemp;
+            // only part 0 can be ThisExpression, anything after must be MemberExpression
+            const part2 = variableParts[1];
+            const property = part2.property;
+            // check that the property is an identifier
+            // we might need to modify this to allow index access (state['foo'] instead of state.foo
+            if (NodeIsPrivateName(property)) {
+              throw new TungstenError('Babel Plugin Transform Bind Error:' + ' Expected bind object property to be an Identifier' + ` Instead got ${property.type}`);
+            }
+            if (!ExpressionIsIdentifier(property)) {
+              throw new TungstenError('Babel Plugin Transform Bind Error:' + ' Expected bind object property to be an Identifier' + ` Instead got ${property.type}`);
+            }
+            let variable = make.memberExpression(make.identifier('this'),
+            // only part 0 can be ThisExpression, anything after must be MemberExpression
+            property);
+            const stateBased = property.name === 'state';
+            // // rename the attribute to 'value' for state based (controlled value)
+            // // or otherwise defaultValue (uncontrolled input)
+            // path.node.name.name = (stateBased)
+            //     ? 'value'
+            //     : 'defaultValue'
+            // just always use value as our framework doesn't understand defaultValue yet
+            path.node.name.name = 'value';
+            for (let i = 2; i < variableParts.length; i++) {
+              // only part 0 can be other than MemberExpression
+              const varPart = variableParts[i];
+              variable = make.memberExpression(variable, varPart.property, varPart.computed);
+            }
+            //// !!!! turn null/false/undef into empty string
+            //// it's nice, but would lead to inconsistency with ordinary
+            //// value = behaviour : (
+            // const valueContents = t.callExpression(
+            //     t.memberExpression(
+            //         t.identifier('this'),
+            //         t.identifier('__filterText')
+            //     ),
+            //     [variable]
+            // )
+            // path.node.value.expression = valueContents
+            // path.node.value.expression = variable
+            let originalOnChange = null;
+            let filter = null;
+            const parent = path.parent;
+            AssertNodeIsJSXOpeningElement(parent);
+            for (const att of parent.attributes) {
+              if (att.type === 'JSXAttribute') {
+                if (att.name.name === 'onChange') {
+                  if (att.value?.type !== 'JSXExpressionContainer') {
+                    throwError('BabelTransformBindDirect', 'the onChange attribute must contain a JSX expression');
+                  }
+                  if (att.value.expression.type === 'JSXEmptyExpression') {
+                    throwError('BabelTransformBindDirect', 'the onChange attribute contains an empty JSX expression');
+                  }
+                  originalOnChange = make.expressionStatement(make.callExpression(att.value.expression, [make.identifier('event'), make.identifier('value')]));
+                }
+                if (att.name.name === 'filter') {
+                  if (att.value?.type !== 'JSXExpressionContainer') {
+                    throwError('BabelTransformBindDirect', 'the filter attribute must contain a JSX expression');
+                  }
+                  if (att.value.expression.type === 'JSXEmptyExpression') {
+                    throwError('BabelTransformBindDirect', 'the filter attribute contains an empty JSX expression');
+                  }
+                  filter = make.variableDeclaration('const', [make.variableDeclarator(make.identifier('value'), make.callExpression(att.value.expression, [make.memberExpression(make.memberExpression(make.identifier('event'), make.identifier('target')), make.identifier('value')), make.identifier('event')]))]);
+                }
+              }
+            }
+            // remove the original onChange attribute(s)
+            parent.attributes = parent.attributes.filter(att => att.type !== 'JSXAttribute' || att.name.name !== 'onChange' && att.name.name !== 'filter');
+            const stateSettingMode = 'assignment';
+            let setStateExpression;
+            let stateAssignmentExpression;
+            let setFieldExpression;
+            if (stateBased) {
+              if (stateSettingMode === 'assignment') {
+                stateAssignmentExpression = make.expressionStatement(make.assignmentExpression('=', originalVariable, make.identifier('value')));
+              } else {
+                //// unused
+                //// would only be useful for a back compat mode
+                if (variableParts.length === 3) {
+                  // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+                  const stateProperty = variableParts[2]?.property;
+                  if (stateProperty?.type !== 'Identifier') {
+                    throwError('BabelTransformBindDirect', 'setState requires an identifier state property');
+                  }
+                  setStateExpression = make.expressionStatement(make.callExpression(make.memberExpression(make.identifier('this'), make.identifier('setState')), [make.objectExpression([make.objectProperty(make.stringLiteral(stateProperty.name), make.identifier('value'))])]));
+                } else {
+                  setStateExpression = make.expressionStatement(make.callExpression(make.memberExpression(make.identifier('this'), make.identifier('setStateDeep')), [make.arrayExpression(variableParts.filter((p, k) => k >= 2).map(p => {
+                    if (p.type !== 'MemberExpression') {
+                      throwError('BabelTransformBindDirect', `expected a member expression; received ${p.type}`);
+                    }
+                    if (p.computed) {
+                      if (p.property.type === 'PrivateName') {
+                        throwError('BabelTransformBindDirect', 'computed bind paths cannot contain private names');
+                      }
+                      return p.property;
+                    }
+                    if (p.property.type !== 'Identifier') {
+                      throwError('BabelTransformBindDirect', `non-computed member property must be an identifier; received ${p.property.type}`);
+                    }
+                    return make.stringLiteral(p.property.name);
+                  })), make.identifier('value')]));
+                }
+              }
+            } else {
+              setFieldExpression = make.expressionStatement(make.assignmentExpression('=', variable, make.identifier('value')));
+            }
+            const functionBodyExpressions = [];
+            const assignToValueVarExpression = make.variableDeclaration('const', [make.variableDeclarator(make.identifier('value'), make.memberExpression(make.memberExpression(make.identifier('event'), make.identifier('target')), make.identifier('value')))]);
+            if (filter) functionBodyExpressions.push(filter); // eslint-disable-line @typescript-eslint/strict-boolean-expressions
+            else functionBodyExpressions.push(assignToValueVarExpression);
+            if (stateBased) {
+              if (stateSettingMode === 'assignment') {
+                if (stateAssignmentExpression === undefined) {
+                  throwError('BabelTransformBindDirect', 'failed to create the state assignment expression');
+                }
+                functionBodyExpressions.push(stateAssignmentExpression);
+              } else {
+                //// unused
+                //// would only be useful for a back compat mode
+                if (setStateExpression === undefined) {
+                  throwError('BabelTransformBindDirect', 'failed to create the setState expression');
+                }
+                functionBodyExpressions.push(setStateExpression);
+              }
+            } else {
+              if (setFieldExpression === undefined) {
+                throwError('BabelTransformBindDirect', 'failed to create the field assignment expression');
+              }
+              functionBodyExpressions.push(setFieldExpression);
+            }
+            if (originalOnChange) functionBodyExpressions.push(originalOnChange); // eslint-disable-line @typescript-eslint/strict-boolean-expressions
+            const attr = make.jsxAttribute(make.jsxIdentifier('onKeyUp'), make.jsxExpressionContainer(make.arrowFunctionExpression([make.identifier('event')], make.blockStatement(functionBodyExpressions))));
+            parent.attributes.push(attr);
+          }
+        }
+      }
+    };
+  };
+}

package/dist/babelPlugins/BabelTransformBindVar.d.ts

@@ -0,0 +1,9 @@
+import type { BabelFake } from './BabelFakeType.js';
+import { NodePath, PluginPass, types } from '@babel/core';
+export declare function MakeBabelTransformBindVar(): (babel: BabelFake) => {
+    name: string;
+    visitor: {
+        JSXAttribute(path: NodePath<types.JSXAttribute>, state: PluginPass): void;
+    };
+};
+//# sourceMappingURL=BabelTransformBindVar.d.ts.map

package/dist/babelPlugins/BabelTransformBindVar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BabelTransformBindVar.d.ts","sourceRoot":"","sources":["../../src/babelPlugins/BabelTransformBindVar.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAS,MAAM,aAAa,CAAA;AA0FhE,wBAAgB,yBAAyB,KACC,OAAO,SAAS;;;2BAKvB,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,UAAU;;EAgRjF"}